@arke-institute/sdk 0.1.3 → 2.1.0

package/dist/edit/index.js

@@ -1,1447 +0,0 @@
-// src/edit/types.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 10,
-  baseDelay: 100,
-  maxDelay: 5e3,
-  jitterFactor: 0.3
-};
-
-// src/edit/errors.ts
-var EditError = class extends Error {
-  constructor(message, code = "UNKNOWN_ERROR", details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "EditError";
-  }
-};
-var EntityNotFoundError = class extends EditError {
-  constructor(id) {
-    super(`Entity not found: ${id}`, "ENTITY_NOT_FOUND", { id });
-    this.name = "EntityNotFoundError";
-  }
-};
-var CASConflictError = class extends EditError {
-  constructor(id, expectedTip, actualTip) {
-    super(
-      `CAS conflict: entity ${id} was modified (expected ${expectedTip}, got ${actualTip})`,
-      "CAS_CONFLICT",
-      { id, expectedTip, actualTip }
-    );
-    this.name = "CASConflictError";
-  }
-};
-var EntityExistsError = class extends EditError {
-  constructor(id) {
-    super(`Entity already exists: ${id}`, "ENTITY_EXISTS", { id });
-    this.name = "EntityExistsError";
-  }
-};
-var MergeError = class extends EditError {
-  constructor(message, sourceId, targetId) {
-    super(message, "MERGE_ERROR", { sourceId, targetId });
-    this.name = "MergeError";
-  }
-};
-var UnmergeError = class extends EditError {
-  constructor(message, sourceId, targetId) {
-    super(message, "UNMERGE_ERROR", { sourceId, targetId });
-    this.name = "UnmergeError";
-  }
-};
-var DeleteError = class extends EditError {
-  constructor(message, id) {
-    super(message, "DELETE_ERROR", { id });
-    this.name = "DeleteError";
-  }
-};
-var UndeleteError = class extends EditError {
-  constructor(message, id) {
-    super(message, "UNDELETE_ERROR", { id });
-    this.name = "UndeleteError";
-  }
-};
-var ReprocessError = class extends EditError {
-  constructor(message, batchId) {
-    super(message, "REPROCESS_ERROR", { batchId });
-    this.name = "ReprocessError";
-  }
-};
-var ValidationError = class extends EditError {
-  constructor(message, field) {
-    super(message, "VALIDATION_ERROR", { field });
-    this.name = "ValidationError";
-  }
-};
-var PermissionError = class extends EditError {
-  constructor(message, id) {
-    super(message, "PERMISSION_DENIED", { id });
-    this.name = "PermissionError";
-  }
-};
-var NetworkError = class extends EditError {
-  constructor(message, statusCode) {
-    super(message, "NETWORK_ERROR", { statusCode });
-    this.name = "NetworkError";
-  }
-};
-var ContentNotFoundError = class extends EditError {
-  constructor(cid) {
-    super(`Content not found: ${cid}`, "CONTENT_NOT_FOUND", { cid });
-    this.name = "ContentNotFoundError";
-  }
-};
-var IPFSError = class extends EditError {
-  constructor(message) {
-    super(message, "IPFS_ERROR");
-    this.name = "IPFSError";
-  }
-};
-var BackendError = class extends EditError {
-  constructor(message) {
-    super(message, "BACKEND_ERROR");
-    this.name = "BackendError";
-  }
-};
-
-// src/edit/client.ts
-var RETRYABLE_STATUS_CODES = [409, 503];
-var RETRYABLE_ERRORS = ["ECONNRESET", "ETIMEDOUT", "fetch failed"];
-var EditClient = class {
-  constructor(config) {
-    this.gatewayUrl = config.gatewayUrl.replace(/\/$/, "");
-    this.authToken = config.authToken;
-    this.network = config.network || "main";
-    this.userId = config.userId;
-    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config.retryConfig };
-    this.statusUrlTransform = config.statusUrlTransform;
-    this.apiPrefix = config.apiPrefix ?? "/api";
-  }
-  // ===========================================================================
-  // Configuration Methods
-  // ===========================================================================
-  /**
-   * Update the auth token (useful for token refresh)
-   */
-  setAuthToken(token) {
-    this.authToken = token;
-  }
-  /**
-   * Set the network (main or test)
-   */
-  setNetwork(network) {
-    this.network = network;
-  }
-  /**
-   * Set the user ID for permission checks
-   */
-  setUserId(userId) {
-    this.userId = userId;
-  }
-  // ===========================================================================
-  // Internal Helpers
-  // ===========================================================================
-  /**
-   * Build URL with API prefix
-   */
-  buildUrl(path) {
-    return `${this.gatewayUrl}${this.apiPrefix}${path}`;
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  getHeaders(contentType = "application/json") {
-    const headers = {};
-    if (contentType) {
-      headers["Content-Type"] = contentType;
-    }
-    if (this.authToken) {
-      headers["Authorization"] = `Bearer ${this.authToken}`;
-    }
-    headers["X-Arke-Network"] = this.network;
-    if (this.userId) {
-      headers["X-User-Id"] = this.userId;
-    }
-    return headers;
-  }
-  calculateDelay(attempt) {
-    const { baseDelay, maxDelay, jitterFactor } = this.retryConfig;
-    const exponentialDelay = baseDelay * Math.pow(2, attempt);
-    const cappedDelay = Math.min(exponentialDelay, maxDelay);
-    const jitter = cappedDelay * jitterFactor * (Math.random() * 2 - 1);
-    return Math.max(0, cappedDelay + jitter);
-  }
-  isRetryableStatus(status) {
-    return RETRYABLE_STATUS_CODES.includes(status);
-  }
-  isRetryableError(error) {
-    const message = error.message.toLowerCase();
-    return RETRYABLE_ERRORS.some((e) => message.includes(e.toLowerCase()));
-  }
-  /**
-   * Execute a fetch with exponential backoff retry on transient errors
-   */
-  async fetchWithRetry(url, options, context) {
-    let lastError = null;
-    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
-      try {
-        const response = await fetch(url, options);
-        if (this.isRetryableStatus(response.status) && attempt < this.retryConfig.maxRetries) {
-          const delay = this.calculateDelay(attempt);
-          lastError = new Error(`${context}: ${response.status} ${response.statusText}`);
-          await this.sleep(delay);
-          continue;
-        }
-        return response;
-      } catch (error) {
-        lastError = error;
-        if (this.isRetryableError(lastError) && attempt < this.retryConfig.maxRetries) {
-          const delay = this.calculateDelay(attempt);
-          await this.sleep(delay);
-          continue;
-        }
-        throw new NetworkError(lastError.message);
-      }
-    }
-    throw lastError || new NetworkError("Request failed after retries");
-  }
-  /**
-   * Handle common error responses and throw appropriate error types
-   */
-  async handleErrorResponse(response, context) {
-    let errorData = {};
-    try {
-      errorData = await response.json();
-    } catch {
-    }
-    const message = errorData.message || `${context}: ${response.statusText}`;
-    const errorCode = errorData.error || "";
-    switch (response.status) {
-      case 400:
-        throw new ValidationError(message);
-      case 403:
-        throw new PermissionError(message);
-      case 404:
-        throw new EntityNotFoundError(message);
-      case 409:
-        if (errorCode === "CAS_FAILURE") {
-          const details = errorData.details;
-          throw new CASConflictError(
-            context,
-            details?.expect || "unknown",
-            details?.actual || "unknown"
-          );
-        }
-        if (errorCode === "CONFLICT") {
-          throw new EntityExistsError(message);
-        }
-        throw new EditError(message, errorCode, errorData.details);
-      case 503:
-        if (errorCode === "IPFS_ERROR") {
-          throw new IPFSError(message);
-        }
-        if (errorCode === "BACKEND_ERROR") {
-          throw new BackendError(message);
-        }
-        throw new NetworkError(message, response.status);
-      default:
-        throw new EditError(message, errorCode || "API_ERROR", { status: response.status });
-    }
-  }
-  // ===========================================================================
-  // Entity CRUD Operations
-  // ===========================================================================
-  /**
-   * Create a new entity
-   */
-  async createEntity(request) {
-    const url = this.buildUrl("/entities");
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      },
-      "Create entity"
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, "Create entity");
-    }
-    return response.json();
-  }
-  /**
-   * Get an entity by ID
-   */
-  async getEntity(id) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}`);
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      `Get entity ${id}`
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Get entity ${id}`);
-    }
-    return response.json();
-  }
-  /**
-   * List entities with pagination
-   */
-  async listEntities(options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit) params.set("limit", options.limit.toString());
-    if (options.cursor) params.set("cursor", options.cursor);
-    if (options.include_metadata) params.set("include_metadata", "true");
-    const queryString = params.toString();
-    const url = this.buildUrl(`/entities${queryString ? `?${queryString}` : ""}`);
-    const response = await this.fetchWithRetry(url, { headers: this.getHeaders() }, "List entities");
-    if (!response.ok) {
-      await this.handleErrorResponse(response, "List entities");
-    }
-    return response.json();
-  }
-  /**
-   * Update an entity (append new version)
-   */
-  async updateEntity(id, update) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}/versions`);
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(update)
-      },
-      `Update entity ${id}`
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Update entity ${id}`);
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Version Operations
-  // ===========================================================================
-  /**
-   * List version history for an entity
-   */
-  async listVersions(id, options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit) params.set("limit", options.limit.toString());
-    if (options.cursor) params.set("cursor", options.cursor);
-    const queryString = params.toString();
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}/versions${queryString ? `?${queryString}` : ""}`);
-    const response = await this.fetchWithRetry(url, { headers: this.getHeaders() }, `List versions for ${id}`);
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `List versions for ${id}`);
-    }
-    return response.json();
-  }
-  /**
-   * Get a specific version of an entity
-   */
-  async getVersion(id, selector) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}/versions/${encodeURIComponent(selector)}`);
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      `Get version ${selector} for ${id}`
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Get version ${selector} for ${id}`);
-    }
-    return response.json();
-  }
-  /**
-   * Resolve an entity ID to its current tip CID (fast lookup)
-   */
-  async resolve(id) {
-    const url = this.buildUrl(`/resolve/${encodeURIComponent(id)}`);
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      `Resolve ${id}`
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Resolve ${id}`);
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Hierarchy Operations
-  // ===========================================================================
-  /**
-   * Update parent-child hierarchy relationships
-   */
-  async updateHierarchy(request) {
-    const apiRequest = {
-      parent_pi: request.parent_id,
-      expect_tip: request.expect_tip,
-      add_children: request.add_children,
-      remove_children: request.remove_children,
-      note: request.note
-    };
-    const url = this.buildUrl("/hierarchy");
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(apiRequest)
-      },
-      `Update hierarchy for ${request.parent_id}`
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Update hierarchy for ${request.parent_id}`);
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Merge Operations
-  // ===========================================================================
-  /**
-   * Merge source entity into target entity
-   */
-  async mergeEntity(sourceId, request) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(sourceId)}/merge`);
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      },
-      `Merge ${sourceId} into ${request.target_id}`
-    );
-    if (!response.ok) {
-      try {
-        const error = await response.json();
-        throw new MergeError(
-          error.message || `Merge failed: ${response.statusText}`,
-          sourceId,
-          request.target_id
-        );
-      } catch (e) {
-        if (e instanceof MergeError) throw e;
-        await this.handleErrorResponse(response, `Merge ${sourceId}`);
-      }
-    }
-    return response.json();
-  }
-  /**
-   * Unmerge (restore) a previously merged entity
-   */
-  async unmergeEntity(sourceId, request) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(sourceId)}/unmerge`);
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      },
-      `Unmerge ${sourceId}`
-    );
-    if (!response.ok) {
-      try {
-        const error = await response.json();
-        throw new UnmergeError(
-          error.message || `Unmerge failed: ${response.statusText}`,
-          sourceId,
-          request.target_id
-        );
-      } catch (e) {
-        if (e instanceof UnmergeError) throw e;
-        await this.handleErrorResponse(response, `Unmerge ${sourceId}`);
-      }
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Delete Operations
-  // ===========================================================================
-  /**
-   * Soft delete an entity (creates tombstone, preserves history)
-   */
-  async deleteEntity(id, request) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}/delete`);
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      },
-      `Delete ${id}`
-    );
-    if (!response.ok) {
-      try {
-        const error = await response.json();
-        throw new DeleteError(error.message || `Delete failed: ${response.statusText}`, id);
-      } catch (e) {
-        if (e instanceof DeleteError) throw e;
-        await this.handleErrorResponse(response, `Delete ${id}`);
-      }
-    }
-    return response.json();
-  }
-  /**
-   * Restore a deleted entity
-   */
-  async undeleteEntity(id, request) {
-    const url = this.buildUrl(`/entities/${encodeURIComponent(id)}/undelete`);
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      },
-      `Undelete ${id}`
-    );
-    if (!response.ok) {
-      try {
-        const error = await response.json();
-        throw new UndeleteError(error.message || `Undelete failed: ${response.statusText}`, id);
-      } catch (e) {
-        if (e instanceof UndeleteError) throw e;
-        await this.handleErrorResponse(response, `Undelete ${id}`);
-      }
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Content Operations
-  // ===========================================================================
-  /**
-   * Upload files to IPFS
-   */
-  async upload(files) {
-    let formData;
-    if (files instanceof FormData) {
-      formData = files;
-    } else {
-      formData = new FormData();
-      const fileArray = Array.isArray(files) ? files : [files];
-      for (const file of fileArray) {
-        if (file instanceof File) {
-          formData.append("file", file, file.name);
-        } else {
-          formData.append("file", file, "file");
-        }
-      }
-    }
-    const url = this.buildUrl("/upload");
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(null),
-        // No Content-Type for multipart
-        body: formData
-      },
-      "Upload files"
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, "Upload files");
-    }
-    return response.json();
-  }
-  /**
-   * Upload text content and return CID
-   */
-  async uploadContent(content, filename) {
-    const blob = new Blob([content], { type: "text/plain" });
-    const file = new File([blob], filename, { type: "text/plain" });
-    const [result] = await this.upload(file);
-    return result.cid;
-  }
-  /**
-   * Download file content by CID
-   */
-  async getContent(cid) {
-    const url = this.buildUrl(`/cat/${encodeURIComponent(cid)}`);
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      `Get content ${cid}`
-    );
-    if (response.status === 404) {
-      throw new ContentNotFoundError(cid);
-    }
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Get content ${cid}`);
-    }
-    return response.text();
-  }
-  /**
-   * Download a DAG node (JSON) by CID
-   */
-  async getDag(cid) {
-    const url = this.buildUrl(`/dag/${encodeURIComponent(cid)}`);
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      `Get DAG ${cid}`
-    );
-    if (response.status === 404) {
-      throw new ContentNotFoundError(cid);
-    }
-    if (!response.ok) {
-      await this.handleErrorResponse(response, `Get DAG ${cid}`);
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Arke Origin Operations
-  // ===========================================================================
-  /**
-   * Get the Arke origin block (genesis entity)
-   */
-  async getArke() {
-    const url = this.buildUrl("/arke");
-    const response = await this.fetchWithRetry(
-      url,
-      { headers: this.getHeaders() },
-      "Get Arke"
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, "Get Arke");
-    }
-    return response.json();
-  }
-  /**
-   * Initialize the Arke origin block (creates if doesn't exist)
-   */
-  async initArke() {
-    const url = this.buildUrl("/arke/init");
-    const response = await this.fetchWithRetry(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders()
-      },
-      "Init Arke"
-    );
-    if (!response.ok) {
-      await this.handleErrorResponse(response, "Init Arke");
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Reprocess API Operations (via /reprocess/*)
-  // ===========================================================================
-  /**
-   * Trigger reprocessing for an entity
-   */
-  async reprocess(request) {
-    const response = await this.fetchWithRetry(
-      `${this.gatewayUrl}/reprocess/reprocess`,
-      {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify({
-          pi: request.pi,
-          phases: request.phases,
-          cascade: request.cascade,
-          options: request.options
-        })
-      },
-      `Reprocess ${request.pi}`
-    );
-    if (response.status === 403) {
-      const error = await response.json().catch(() => ({}));
-      throw new PermissionError(
-        error.message || `Permission denied to reprocess ${request.pi}`,
-        request.pi
-      );
-    }
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new ReprocessError(error.message || `Reprocess failed: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  /**
-   * Get reprocessing status by batch ID
-   */
-  async getReprocessStatus(statusUrl, isFirstPoll = false) {
-    const fetchUrl = this.statusUrlTransform ? this.statusUrlTransform(statusUrl) : statusUrl;
-    const delay = isFirstPoll ? 3e3 : this.retryConfig.baseDelay;
-    if (isFirstPoll) {
-      await this.sleep(delay);
-    }
-    const response = await this.fetchWithRetry(
-      fetchUrl,
-      { headers: this.getHeaders() },
-      "Get reprocess status"
-    );
-    if (!response.ok) {
-      throw new EditError(
-        `Failed to fetch reprocess status: ${response.statusText}`,
-        "STATUS_ERROR",
-        { status: response.status }
-      );
-    }
-    return response.json();
-  }
-  // ===========================================================================
-  // Utility Methods
-  // ===========================================================================
-  /**
-   * Execute an operation with automatic CAS retry
-   */
-  async withCAS(id, operation, maxRetries = 3) {
-    let lastError = null;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        const entity = await this.getEntity(id);
-        return await operation(entity);
-      } catch (error) {
-        if (error instanceof CASConflictError && attempt < maxRetries - 1) {
-          lastError = error;
-          const delay = this.calculateDelay(attempt);
-          await this.sleep(delay);
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw lastError || new EditError("withCAS failed after retries");
-  }
-};
-
-// src/edit/diff.ts
-import * as Diff from "diff";
-var DiffEngine = class {
-  /**
-   * Compute diff between two strings
-   */
-  static diff(original, modified) {
-    const changes = Diff.diffLines(original, modified);
-    const diffs = [];
-    let lineNumber = 1;
-    for (const change of changes) {
-      if (change.added) {
-        diffs.push({
-          type: "addition",
-          modified: change.value.trimEnd(),
-          lineNumber
-        });
-      } else if (change.removed) {
-        diffs.push({
-          type: "deletion",
-          original: change.value.trimEnd(),
-          lineNumber
-        });
-      } else {
-        const lines = change.value.split("\n").length - 1;
-        lineNumber += lines;
-      }
-      if (change.added) {
-        lineNumber += change.value.split("\n").length - 1;
-      }
-    }
-    return diffs;
-  }
-  /**
-   * Compute word-level diff for more granular changes
-   */
-  static diffWords(original, modified) {
-    const changes = Diff.diffWords(original, modified);
-    const diffs = [];
-    for (const change of changes) {
-      if (change.added) {
-        diffs.push({
-          type: "addition",
-          modified: change.value
-        });
-      } else if (change.removed) {
-        diffs.push({
-          type: "deletion",
-          original: change.value
-        });
-      }
-    }
-    return diffs;
-  }
-  /**
-   * Create a ComponentDiff from original and modified content
-   */
-  static createComponentDiff(componentName, original, modified) {
-    const diffs = this.diff(original, modified);
-    const hasChanges = diffs.length > 0;
-    let summary;
-    if (!hasChanges) {
-      summary = "No changes";
-    } else {
-      const additions = diffs.filter((d) => d.type === "addition").length;
-      const deletions = diffs.filter((d) => d.type === "deletion").length;
-      const parts = [];
-      if (additions > 0) parts.push(`${additions} addition${additions > 1 ? "s" : ""}`);
-      if (deletions > 0) parts.push(`${deletions} deletion${deletions > 1 ? "s" : ""}`);
-      summary = parts.join(", ");
-    }
-    return {
-      componentName,
-      diffs,
-      summary,
-      hasChanges
-    };
-  }
-  /**
-   * Format diffs for AI prompt consumption
-   */
-  static formatForPrompt(diffs) {
-    if (diffs.length === 0) {
-      return "No changes detected.";
-    }
-    const lines = [];
-    for (const diff of diffs) {
-      const linePrefix = diff.lineNumber ? `Line ${diff.lineNumber}: ` : "";
-      if (diff.type === "addition") {
-        lines.push(`${linePrefix}+ ${diff.modified}`);
-      } else if (diff.type === "deletion") {
-        lines.push(`${linePrefix}- ${diff.original}`);
-      } else if (diff.type === "change") {
-        lines.push(`${linePrefix}"${diff.original}" \u2192 "${diff.modified}"`);
-      }
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Format component diffs for AI prompt
-   */
-  static formatComponentDiffsForPrompt(componentDiffs) {
-    const sections = [];
-    for (const cd of componentDiffs) {
-      if (!cd.hasChanges) continue;
-      sections.push(`## Changes to ${cd.componentName}:`);
-      sections.push(this.formatForPrompt(cd.diffs));
-      sections.push("");
-    }
-    return sections.join("\n");
-  }
-  /**
-   * Create a unified diff view
-   */
-  static unifiedDiff(original, modified, options) {
-    const filename = options?.filename || "content";
-    const patch = Diff.createPatch(filename, original, modified, "", "", {
-      context: options?.context ?? 3
-    });
-    return patch;
-  }
-  /**
-   * Extract corrections from diffs (specific text replacements)
-   */
-  static extractCorrections(original, modified, sourceFile) {
-    const wordDiffs = Diff.diffWords(original, modified);
-    const corrections = [];
-    let i = 0;
-    while (i < wordDiffs.length) {
-      const current = wordDiffs[i];
-      if (current.removed && i + 1 < wordDiffs.length && wordDiffs[i + 1].added) {
-        const removed = current.value.trim();
-        const added = wordDiffs[i + 1].value.trim();
-        if (removed && added && removed !== added) {
-          corrections.push({
-            original: removed,
-            corrected: added,
-            sourceFile
-          });
-        }
-        i += 2;
-      } else {
-        i++;
-      }
-    }
-    return corrections;
-  }
-  /**
-   * Check if two strings are meaningfully different
-   * (ignoring whitespace differences)
-   */
-  static hasSignificantChanges(original, modified) {
-    const normalizedOriginal = original.replace(/\s+/g, " ").trim();
-    const normalizedModified = modified.replace(/\s+/g, " ").trim();
-    return normalizedOriginal !== normalizedModified;
-  }
-};
-
-// src/edit/prompts.ts
-var PromptBuilder = class {
-  /**
-   * Build prompt for AI-first mode (user provides instructions)
-   */
-  static buildAIPrompt(userPrompt, component, entityContext, currentContent) {
-    const sections = [];
-    sections.push(`## Instructions for ${component}`);
-    sections.push(userPrompt);
-    sections.push("");
-    sections.push("## Entity Context");
-    sections.push(`- PI: ${entityContext.pi}`);
-    sections.push(`- Current version: ${entityContext.ver}`);
-    if (entityContext.parentPi) {
-      sections.push(`- Parent: ${entityContext.parentPi}`);
-    }
-    if (entityContext.childrenCount > 0) {
-      sections.push(`- Children: ${entityContext.childrenCount}`);
-    }
-    sections.push("");
-    if (currentContent) {
-      sections.push(`## Current ${component} content for reference:`);
-      sections.push("```");
-      sections.push(currentContent.slice(0, 2e3));
-      if (currentContent.length > 2e3) {
-        sections.push("... [truncated]");
-      }
-      sections.push("```");
-    }
-    return sections.join("\n");
-  }
-  /**
-   * Build prompt incorporating manual edits and diffs
-   */
-  static buildEditReviewPrompt(componentDiffs, corrections, component, userInstructions) {
-    const sections = [];
-    sections.push("## Manual Edits Made");
-    sections.push("");
-    sections.push("The following manual edits were made to this entity:");
-    sections.push("");
-    const diffContent = DiffEngine.formatComponentDiffsForPrompt(componentDiffs);
-    if (diffContent) {
-      sections.push(diffContent);
-    }
-    if (corrections.length > 0) {
-      sections.push("## Corrections Identified");
-      sections.push("");
-      for (const correction of corrections) {
-        const source = correction.sourceFile ? ` (in ${correction.sourceFile})` : "";
-        sections.push(`- "${correction.original}" \u2192 "${correction.corrected}"${source}`);
-      }
-      sections.push("");
-    }
-    sections.push("## Instructions");
-    if (userInstructions) {
-      sections.push(userInstructions);
-    } else {
-      sections.push(
-        `Update the ${component} to accurately reflect these changes. Ensure any corrections are incorporated and the content is consistent.`
-      );
-    }
-    sections.push("");
-    sections.push("## Guidance");
-    switch (component) {
-      case "pinax":
-        sections.push(
-          "Update metadata fields to reflect any corrections. Pay special attention to dates, names, and other factual information that may have been corrected."
-        );
-        break;
-      case "description":
-        sections.push(
-          "Regenerate the description incorporating the changes. Maintain the overall tone and structure while ensuring accuracy based on the corrections."
-        );
-        break;
-      case "cheimarros":
-        sections.push(
-          "Update the knowledge graph to reflect any new or corrected entities, relationships, and facts identified in the changes."
-        );
-        break;
-    }
-    return sections.join("\n");
-  }
-  /**
-   * Build cascade-aware prompt additions
-   */
-  static buildCascadePrompt(basePrompt, cascadeContext) {
-    const sections = [basePrompt];
-    sections.push("");
-    sections.push("## Cascade Context");
-    sections.push("");
-    sections.push(
-      "This edit is part of a cascading update. After updating this entity, parent entities will also be updated to reflect these changes."
-    );
-    sections.push("");
-    if (cascadeContext.path.length > 1) {
-      sections.push(`Cascade path: ${cascadeContext.path.join(" \u2192 ")}`);
-      sections.push(`Depth: ${cascadeContext.depth}`);
-    }
-    if (cascadeContext.stopAtPi) {
-      sections.push(`Cascade will stop at: ${cascadeContext.stopAtPi}`);
-    }
-    sections.push("");
-    sections.push(
-      "Ensure the content accurately represents the source material so parent aggregations will be correct."
-    );
-    return sections.join("\n");
-  }
-  /**
-   * Build a general prompt combining multiple instructions
-   */
-  static buildCombinedPrompt(generalPrompt, componentPrompt, component) {
-    const sections = [];
-    if (generalPrompt) {
-      sections.push("## General Instructions");
-      sections.push(generalPrompt);
-      sections.push("");
-    }
-    if (componentPrompt) {
-      sections.push(`## Specific Instructions for ${component}`);
-      sections.push(componentPrompt);
-      sections.push("");
-    }
-    if (sections.length === 0) {
-      return `Regenerate the ${component} based on the current entity content.`;
-    }
-    return sections.join("\n");
-  }
-  /**
-   * Build prompt for correction-based updates
-   */
-  static buildCorrectionPrompt(corrections) {
-    if (corrections.length === 0) {
-      return "";
-    }
-    const sections = [];
-    sections.push("## Corrections Applied");
-    sections.push("");
-    sections.push("The following corrections were made to the source content:");
-    sections.push("");
-    for (const correction of corrections) {
-      const source = correction.sourceFile ? ` in ${correction.sourceFile}` : "";
-      sections.push(`- "${correction.original}" was corrected to "${correction.corrected}"${source}`);
-      if (correction.context) {
-        sections.push(`  Context: ${correction.context}`);
-      }
-    }
-    sections.push("");
-    sections.push(
-      "Update the metadata and description to reflect these corrections. Previous content may have contained errors based on the incorrect text."
-    );
-    return sections.join("\n");
-  }
-  /**
-   * Get component-specific regeneration guidance
-   */
-  static getComponentGuidance(component) {
-    switch (component) {
-      case "pinax":
-        return "Extract and structure metadata including: institution, creator, title, date range, subjects, type, and other relevant fields. Ensure accuracy based on the source content.";
-      case "description":
-        return "Generate a clear, informative description that summarizes the entity content. Focus on what the material contains, its historical significance, and context. Write for a general audience unless otherwise specified.";
-      case "cheimarros":
-        return "Extract entities (people, places, organizations, events) and their relationships. Build a knowledge graph that captures the key facts and connections in the content.";
-      default:
-        return "";
-    }
-  }
-};
-
-// src/edit/session.ts
-var DEFAULT_SCOPE = {
-  components: [],
-  cascade: false
-};
-var DEFAULT_POLL_OPTIONS = {
-  intervalMs: 2e3,
-  timeoutMs: 3e5
-  // 5 minutes
-};
-var EditSession = class {
-  constructor(client, pi, config) {
-    this.entity = null;
-    this.loadedComponents = {};
-    // AI mode state
-    this.prompts = {};
-    // Manual mode state
-    this.editedContent = {};
-    this.corrections = [];
-    // Scope
-    this.scope = { ...DEFAULT_SCOPE };
-    // Execution state
-    this.submitting = false;
-    this.result = null;
-    this.statusUrl = null;
-    this.client = client;
-    this.pi = pi;
-    this.mode = config?.mode ?? "ai-prompt";
-    this.aiReviewEnabled = config?.aiReviewEnabled ?? true;
-  }
-  // ===========================================================================
-  // Loading
-  // ===========================================================================
-  /**
-   * Load the entity and its key components
-   */
-  async load() {
-    this.entity = await this.client.getEntity(this.pi);
-    const priorityComponents = ["description.md", "pinax.json", "cheimarros.json"];
-    await Promise.all(
-      priorityComponents.map(async (name) => {
-        const cid = this.entity.components[name];
-        if (cid) {
-          try {
-            this.loadedComponents[name] = await this.client.getContent(cid);
-          } catch {
-          }
-        }
-      })
-    );
-  }
-  /**
-   * Load a specific component on demand
-   */
-  async loadComponent(name) {
-    if (this.loadedComponents[name]) {
-      return this.loadedComponents[name];
-    }
-    if (!this.entity) {
-      throw new ValidationError("Session not loaded");
-    }
-    const cid = this.entity.components[name];
-    if (!cid) {
-      return void 0;
-    }
-    const content = await this.client.getContent(cid);
-    this.loadedComponents[name] = content;
-    return content;
-  }
-  /**
-   * Get the loaded entity
-   */
-  getEntity() {
-    if (!this.entity) {
-      throw new ValidationError("Session not loaded. Call load() first.");
-    }
-    return this.entity;
-  }
-  /**
-   * Get loaded component content
-   */
-  getComponents() {
-    return { ...this.loadedComponents };
-  }
-  // ===========================================================================
-  // AI Prompt Mode
-  // ===========================================================================
-  /**
-   * Set a prompt for AI regeneration
-   */
-  setPrompt(target, prompt) {
-    if (this.mode === "manual-only") {
-      throw new ValidationError("Cannot set prompts in manual-only mode");
-    }
-    this.prompts[target] = prompt;
-  }
-  /**
-   * Get all prompts
-   */
-  getPrompts() {
-    return { ...this.prompts };
-  }
-  /**
-   * Clear a prompt
-   */
-  clearPrompt(target) {
-    delete this.prompts[target];
-  }
-  // ===========================================================================
-  // Manual Edit Mode
-  // ===========================================================================
-  /**
-   * Set edited content for a component
-   */
-  setContent(componentName, content) {
-    if (this.mode === "ai-prompt") {
-      throw new ValidationError("Cannot set content in ai-prompt mode");
-    }
-    this.editedContent[componentName] = content;
-  }
-  /**
-   * Get all edited content
-   */
-  getEditedContent() {
-    return { ...this.editedContent };
-  }
-  /**
-   * Clear edited content for a component
-   */
-  clearContent(componentName) {
-    delete this.editedContent[componentName];
-  }
-  /**
-   * Add a correction (for OCR fixes, etc.)
-   */
-  addCorrection(original, corrected, sourceFile) {
-    this.corrections.push({ original, corrected, sourceFile });
-  }
-  /**
-   * Get all corrections
-   */
-  getCorrections() {
-    return [...this.corrections];
-  }
-  /**
-   * Clear corrections
-   */
-  clearCorrections() {
-    this.corrections = [];
-  }
-  // ===========================================================================
-  // Scope Configuration
-  // ===========================================================================
-  /**
-   * Set the edit scope
-   */
-  setScope(scope) {
-    this.scope = { ...this.scope, ...scope };
-  }
-  /**
-   * Get the current scope
-   */
-  getScope() {
-    return { ...this.scope };
-  }
-  // ===========================================================================
-  // Preview & Summary
-  // ===========================================================================
-  /**
-   * Get diffs for manual changes
-   */
-  getDiff() {
-    const diffs = [];
-    for (const [name, edited] of Object.entries(this.editedContent)) {
-      const original = this.loadedComponents[name] || "";
-      if (DiffEngine.hasSignificantChanges(original, edited)) {
-        diffs.push(DiffEngine.createComponentDiff(name, original, edited));
-      }
-    }
-    return diffs;
-  }
-  /**
-   * Preview what prompts will be sent to AI
-   */
-  previewPrompt() {
-    const result = {};
-    if (!this.entity) return result;
-    const entityContext = {
-      pi: this.entity.id,
-      ver: this.entity.ver,
-      parentPi: this.entity.parent_pi,
-      childrenCount: this.entity.children_pi?.length ?? 0,
-      currentContent: this.loadedComponents
-    };
-    for (const component of this.scope.components) {
-      let prompt;
-      if (this.mode === "ai-prompt") {
-        const componentPrompt = this.prompts[component];
-        const generalPrompt = this.prompts["general"];
-        const combined = PromptBuilder.buildCombinedPrompt(generalPrompt, componentPrompt, component);
-        prompt = PromptBuilder.buildAIPrompt(
-          combined,
-          component,
-          entityContext,
-          this.loadedComponents[`${component}.json`] || this.loadedComponents[`${component}.md`]
-        );
-      } else {
-        const diffs = this.getDiff();
-        const userInstructions = this.prompts["general"] || this.prompts[component];
-        prompt = PromptBuilder.buildEditReviewPrompt(diffs, this.corrections, component, userInstructions);
-      }
-      if (this.scope.cascade) {
-        prompt = PromptBuilder.buildCascadePrompt(prompt, {
-          path: [this.entity.id, this.entity.parent_pi || "root"].filter(Boolean),
-          depth: 0,
-          stopAtPi: this.scope.stopAtPi
-        });
-      }
-      result[component] = prompt;
-    }
-    return result;
-  }
-  /**
-   * Get a summary of pending changes
-   */
-  getChangeSummary() {
-    const diffs = this.getDiff();
-    const hasManualEdits = diffs.some((d) => d.hasChanges);
-    return {
-      mode: this.mode,
-      hasManualEdits,
-      editedComponents: Object.keys(this.editedContent),
-      corrections: [...this.corrections],
-      prompts: { ...this.prompts },
-      scope: { ...this.scope },
-      willRegenerate: [...this.scope.components],
-      willCascade: this.scope.cascade,
-      willSave: hasManualEdits,
-      willReprocess: this.scope.components.length > 0
-    };
-  }
-  // ===========================================================================
-  // Execution
-  // ===========================================================================
-  /**
-   * Submit changes (saves first if manual edits, then reprocesses)
-   */
-  async submit(note) {
-    if (this.submitting) {
-      throw new ValidationError("Submit already in progress");
-    }
-    if (!this.entity) {
-      throw new ValidationError("Session not loaded. Call load() first.");
-    }
-    this.submitting = true;
-    this.result = {};
-    try {
-      const diffs = this.getDiff();
-      const hasManualEdits = diffs.some((d) => d.hasChanges);
-      if (hasManualEdits) {
-        const componentUpdates = {};
-        for (const [name, content] of Object.entries(this.editedContent)) {
-          const original = this.loadedComponents[name] || "";
-          if (DiffEngine.hasSignificantChanges(original, content)) {
-            const cid = await this.client.uploadContent(content, name);
-            componentUpdates[name] = cid;
-          }
-        }
-        const version = await this.client.updateEntity(this.pi, {
-          expect_tip: this.entity.manifest_cid,
-          components: componentUpdates,
-          note
-        });
-        this.result.saved = {
-          pi: version.id,
-          newVersion: version.ver,
-          newTip: version.tip
-        };
-        this.entity.manifest_cid = version.tip;
-        this.entity.ver = version.ver;
-      }
-      if (this.scope.components.length > 0) {
-        const customPrompts = this.buildCustomPrompts();
-        const reprocessResult = await this.client.reprocess({
-          pi: this.pi,
-          phases: this.scope.components,
-          cascade: this.scope.cascade,
-          options: {
-            stop_at_pi: this.scope.stopAtPi,
-            custom_prompts: customPrompts,
-            custom_note: note
-          }
-        });
-        this.result.reprocess = reprocessResult;
-        this.statusUrl = reprocessResult.status_url;
-      }
-      return this.result;
-    } finally {
-      this.submitting = false;
-    }
-  }
-  /**
-   * Wait for reprocessing to complete
-   */
-  async waitForCompletion(options) {
-    const opts = { ...DEFAULT_POLL_OPTIONS, ...options };
-    if (!this.statusUrl) {
-      return {
-        phase: "complete",
-        saveComplete: true
-      };
-    }
-    const startTime = Date.now();
-    let isFirstPoll = true;
-    while (true) {
-      const status = await this.client.getReprocessStatus(this.statusUrl, isFirstPoll);
-      isFirstPoll = false;
-      const editStatus = {
-        phase: status.status === "DONE" ? "complete" : status.status === "ERROR" ? "error" : "reprocessing",
-        saveComplete: true,
-        reprocessStatus: status,
-        error: status.error
-      };
-      if (opts.onProgress) {
-        opts.onProgress(editStatus);
-      }
-      if (status.status === "DONE" || status.status === "ERROR") {
-        return editStatus;
-      }
-      if (Date.now() - startTime > opts.timeoutMs) {
-        return {
-          phase: "error",
-          saveComplete: true,
-          reprocessStatus: status,
-          error: "Timeout waiting for reprocessing to complete"
-        };
-      }
-      await new Promise((resolve) => setTimeout(resolve, opts.intervalMs));
-    }
-  }
-  /**
-   * Get current status without waiting
-   */
-  async getStatus() {
-    if (!this.statusUrl) {
-      return {
-        phase: this.result?.saved ? "complete" : "idle",
-        saveComplete: !!this.result?.saved
-      };
-    }
-    const status = await this.client.getReprocessStatus(this.statusUrl);
-    return {
-      phase: status.status === "DONE" ? "complete" : status.status === "ERROR" ? "error" : "reprocessing",
-      saveComplete: true,
-      reprocessStatus: status,
-      error: status.error
-    };
-  }
-  // ===========================================================================
-  // Private Helpers
-  // ===========================================================================
-  buildCustomPrompts() {
-    const custom = {};
-    if (this.mode === "ai-prompt") {
-      if (this.prompts["general"]) custom.general = this.prompts["general"];
-      if (this.prompts["pinax"]) custom.pinax = this.prompts["pinax"];
-      if (this.prompts["description"]) custom.description = this.prompts["description"];
-      if (this.prompts["cheimarros"]) custom.cheimarros = this.prompts["cheimarros"];
-    } else {
-      const diffs = this.getDiff();
-      const diffContext = DiffEngine.formatComponentDiffsForPrompt(diffs);
-      const correctionContext = PromptBuilder.buildCorrectionPrompt(this.corrections);
-      const basePrompt = [diffContext, correctionContext, this.prompts["general"]].filter(Boolean).join("\n\n");
-      if (basePrompt) {
-        custom.general = basePrompt;
-      }
-      if (this.prompts["pinax"]) custom.pinax = this.prompts["pinax"];
-      if (this.prompts["description"]) custom.description = this.prompts["description"];
-      if (this.prompts["cheimarros"]) custom.cheimarros = this.prompts["cheimarros"];
-    }
-    return custom;
-  }
-};
-export {
-  BackendError,
-  CASConflictError,
-  ContentNotFoundError,
-  DEFAULT_RETRY_CONFIG,
-  DeleteError,
-  DiffEngine,
-  EditClient,
-  EditError,
-  EditSession,
-  EntityExistsError,
-  EntityNotFoundError,
-  IPFSError,
-  MergeError,
-  NetworkError,
-  PermissionError,
-  PromptBuilder,
-  ReprocessError,
-  UndeleteError,
-  UnmergeError,
-  ValidationError
-};
-//# sourceMappingURL=index.js.map