mcard-js 2.1.49 → 2.1.51

package/dist/chunk-DTPHGTBQ.js

@@ -0,0 +1,275 @@
+import {
+  createPage
+} from "./chunk-3EIBJPNF.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  init_Handle,
+  validateHandle
+} from "./chunk-ADV52544.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  INDEXEDDB_DEFAULT_DB_NAME,
+  INDEXEDDB_DEFAULT_DB_VERSION
+} from "./chunk-PKLONZCF.js";
+
+// src/storage/engines/IndexedDBEngine.ts
+import { openDB } from "idb";
+init_Handle();
+var IndexedDBEngine = class {
+  db = null;
+  dbName;
+  constructor(dbName = INDEXEDDB_DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  /**
+   * Initialize the database connection
+   */
+  async init() {
+    this.db = await openDB(this.dbName, INDEXEDDB_DEFAULT_DB_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains("cards")) {
+          db.createObjectStore("cards", { keyPath: "hash" });
+        }
+        if (!db.objectStoreNames.contains("handles")) {
+          const handleStore = db.createObjectStore("handles", { keyPath: "handle" });
+          handleStore.createIndex("by-hash", "currentHash");
+        }
+        if (!db.objectStoreNames.contains("handleHistory")) {
+          const historyStore = db.createObjectStore("handleHistory", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          historyStore.createIndex("by-handle", "handle");
+        }
+      }
+    });
+  }
+  ensureDb() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call init() first.");
+    }
+    return this.db;
+  }
+  // =========== Card Operations ===========
+  async add(card) {
+    const db = this.ensureDb();
+    await db.put("cards", {
+      hash: card.hash,
+      content: card.content,
+      g_time: card.g_time
+    });
+    return card.hash;
+  }
+  async get(hash) {
+    const db = this.ensureDb();
+    const record = await db.get("cards", hash);
+    if (!record) return null;
+    return MCard.fromData(record.content, record.hash, record.g_time);
+  }
+  async delete(hash) {
+    const db = this.ensureDb();
+    await db.delete("cards", hash);
+  }
+  async getPage(pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const totalItems = await db.count("cards");
+    const allCards = await db.getAll("cards");
+    const start = (pageNumber - 1) * pageSize;
+    const pageRecords = allCards.slice(start, start + pageSize);
+    const items = pageRecords.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  async count() {
+    const db = this.ensureDb();
+    return db.count("cards");
+  }
+  async searchByHash(hashPrefix) {
+    const db = this.ensureDb();
+    const start = hashPrefix;
+    const end = hashPrefix + "\uFFFF";
+    const range = IDBKeyRange.bound(start, end);
+    const records = await db.getAll("cards", range);
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async search(query, pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    const decoder = new TextDecoder();
+    const filtered = records.filter((r) => {
+      try {
+        const text = decoder.decode(r.content);
+        return text.includes(query);
+      } catch {
+        return false;
+      }
+    });
+    const totalItems = filtered.length;
+    const start = (pageNumber - 1) * pageSize;
+    const pageItems = filtered.slice(start, start + pageSize).map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(pageItems, totalItems, pageNumber, pageSize);
+  }
+  async getAll() {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async clear() {
+    const db = this.ensureDb();
+    await db.clear("cards");
+    await db.clear("handles");
+    await db.clear("handleHistory");
+  }
+  // =========== Handle Operations ===========
+  async registerHandle(handle, hash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (existing) {
+      throw new Error(`Handle '${handle}' already exists.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.put("handles", {
+      handle: normalized,
+      currentHash: hash,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  async resolveHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const record = await db.get("handles", normalized);
+    return record?.currentHash ?? null;
+  }
+  async getByHandle(handle) {
+    const hash = await this.resolveHandle(handle);
+    if (!hash) return null;
+    return this.get(hash);
+  }
+  async updateHandle(handle, newHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (!existing) {
+      throw new Error(`Handle '${handle}' not found.`);
+    }
+    const previousHash = existing.currentHash;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.add("handleHistory", {
+      handle: normalized,
+      previousHash,
+      changedAt: now
+    });
+    await db.put("handles", {
+      ...existing,
+      currentHash: newHash,
+      updatedAt: now
+    });
+    return previousHash;
+  }
+  async getHandleHistory(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    return records.map((r) => ({ previousHash: r.previousHash, changedAt: r.changedAt })).reverse();
+  }
+  async pruneHandleHistory(handle, options = {}) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    let toDelete;
+    if (options.deleteAll) {
+      toDelete = records;
+    } else if (options.olderThan) {
+      toDelete = records.filter((r) => r.changedAt < options.olderThan);
+    } else {
+      return 0;
+    }
+    const tx = db.transaction("handleHistory", "readwrite");
+    for (const record of toDelete) {
+      await tx.store.delete(record.id);
+    }
+    await tx.done;
+    return toDelete.length;
+  }
+  // =========== Handle Management Operations ===========
+  async getAllHandles() {
+    const db = this.ensureDb();
+    const records = await db.getAll("handles");
+    return records.map((r) => ({ handle: r.handle, hash: r.currentHash }));
+  }
+  async removeHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const keysToTry = normalized !== handle.trim() ? [normalized, handle.trim()] : [normalized];
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    for (const key of keysToTry) {
+      await handleStore.delete(key);
+    }
+    const historyIndex = historyStore.index("by-handle");
+    for (const key of keysToTry) {
+      let cursor = await historyIndex.openCursor(key);
+      while (cursor) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+      }
+    }
+    await tx.done;
+  }
+  async renameHandle(oldHandle, newHandle) {
+    const db = this.ensureDb();
+    const normalizedOld = validateHandle(oldHandle);
+    const normalizedNew = validateHandle(newHandle);
+    if (normalizedOld === normalizedNew) return;
+    const oldEntry = await db.get("handles", normalizedOld);
+    if (!oldEntry) throw new Error(`Handle '${oldHandle}' not found.`);
+    const newEntry = await db.get("handles", normalizedNew);
+    if (newEntry) throw new Error(`Handle '${newHandle}' already exists.`);
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await handleStore.put({
+      ...oldEntry,
+      handle: normalizedNew,
+      updatedAt: now
+    });
+    await handleStore.delete(normalizedOld);
+    const historyIndex = historyStore.index("by-handle");
+    let cursor = await historyIndex.openCursor(normalizedOld);
+    while (cursor) {
+      const record = cursor.value;
+      record.handle = normalizedNew;
+      await cursor.update(record);
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  }
+  async deleteHistoryEntry(handle, previousHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    const entries = records.sort((a, b) => a.id - b.id);
+    const targetIdx = entries.findIndex((e) => e.previousHash === previousHash);
+    if (targetIdx === -1) return;
+    const target = entries[targetIdx];
+    const successor = entries[targetIdx + 1];
+    const tx = db.transaction("handleHistory", "readwrite");
+    const store = tx.objectStore("handleHistory");
+    if (successor && targetIdx > 0) {
+      const predecessor = entries[targetIdx - 1];
+      successor.previousHash = predecessor.previousHash;
+      await store.put(successor);
+    }
+    await store.delete(target.id);
+    await tx.done;
+  }
+};
+
+export {
+  IndexedDBEngine
+};

package/dist/chunk-EDAJ5FO6.js

@@ -0,0 +1,405 @@
+import {
+  ContentTypeInterpreter,
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  MAX_FILE_SIZE,
+  READ_TIMEOUT_MS
+} from "./chunk-R3XRBAM7.js";
+import {
+  __export
+} from "./chunk-PNKVD2UK.js";
+
+// src/Loader.ts
+var Loader_exports = {};
+__export(Loader_exports, {
+  exportCollectionToDirectory: () => exportCollectionToDirectory,
+  loadFileToCollection: () => loadFileToCollection,
+  processAndStoreFile: () => processAndStoreFile
+});
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+
+// src/FileIO.ts
+var FileIO_exports = {};
+__export(FileIO_exports, {
+  getTreeHashes: () => getTreeHashes,
+  isProblematicFile: () => isProblematicFile,
+  listFiles: () => listFiles,
+  processFileContent: () => processFileContent,
+  readFileSafely: () => readFileSafely,
+  streamReadNormalizedText: () => streamReadNormalizedText
+});
+import * as crypto from "crypto";
+import * as fs from "fs/promises";
+import * as path from "path";
+async function streamReadNormalizedText(filePath, options) {
+  const { byteCap, wrapWidth } = options;
+  const sha = crypto.createHash("sha256");
+  let totalSize = 0;
+  let producedText = "";
+  let currentLen = 0;
+  const handle = await fs.open(filePath, "r");
+  try {
+    const buffer = new Uint8Array(8192);
+    let remaining = byteCap;
+    const decoder = new TextDecoder("utf-8", { fatal: false });
+    let position = 0;
+    while (remaining > 0) {
+      const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, remaining), position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      const chunk = buffer.subarray(0, bytesRead);
+      sha.update(chunk);
+      totalSize += bytesRead;
+      remaining -= bytesRead;
+      const s2 = decoder.decode(chunk, { stream: true });
+      for (const ch of s2) {
+        if (ch === "\r") continue;
+        producedText += ch;
+        if (ch === "\n") {
+          currentLen = 0;
+        } else {
+          currentLen++;
+          if (wrapWidth > 0 && currentLen >= wrapWidth) {
+            producedText += "\n";
+            currentLen = 0;
+          }
+        }
+      }
+    }
+    const s = decoder.decode();
+    for (const ch of s) {
+      if (ch === "\r") continue;
+      producedText += ch;
+      if (ch === "\n") {
+        currentLen = 0;
+      } else {
+        currentLen++;
+        if (wrapWidth > 0 && currentLen >= wrapWidth) {
+          producedText += "\n";
+          currentLen = 0;
+        }
+      }
+    }
+  } finally {
+    await handle.close();
+  }
+  return {
+    text: producedText,
+    originalSize: totalSize,
+    originalSha256Prefix: sha.digest("hex").substring(0, 16)
+  };
+}
+var MAX_FILE_SIZE2 = MAX_FILE_SIZE;
+var READ_TIMEOUT_MS2 = READ_TIMEOUT_MS;
+async function isProblematicFile(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    if (stats.size === 0) return false;
+    if (path.basename(filePath).startsWith(".")) return true;
+    if (stats.size > MAX_FILE_SIZE2) return true;
+    const ext = path.extname(filePath);
+    const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(ext);
+    if (isKnownType && stats.size > 1024 * 1024) return true;
+    const handle = await fs.open(filePath, "r");
+    try {
+      const buffer = new Uint8Array(32 * 1024);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      const sample = buffer.subarray(0, bytesRead);
+      if (ContentTypeInterpreter.isUnstructuredBinary(sample)) return true;
+      if (ContentTypeInterpreter.hasPathologicalLines(sample, isKnownType)) return true;
+    } finally {
+      await handle.close();
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function readFileSafely(filePath, options = {}) {
+  const stats = await fs.stat(filePath);
+  if (stats.size > MAX_FILE_SIZE2) throw new Error(`File too large: ${stats.size}`);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), READ_TIMEOUT_MS2);
+  try {
+    const handle = await fs.open(filePath, "r");
+    try {
+      const buffer = new Uint8Array(stats.size);
+      await handle.read(buffer, 0, stats.size, 0);
+      return buffer;
+    } finally {
+      await handle.close();
+    }
+  } catch (e) {
+    const error = e;
+    if (error.name === "AbortError") throw new Error(`Read timeout for ${filePath}`);
+    throw e;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function listFiles(dirPath, recursive = false) {
+  let files = [];
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isDirectory()) {
+        if (recursive) {
+          files = files.concat(await listFiles(fullPath, true));
+        }
+      } else if (entry.isFile()) {
+        if (!await isProblematicFile(fullPath)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (e) {
+    console.warn(`Error listing directory ${dirPath}:`, e);
+  }
+  return files;
+}
+async function processFileContent(filePath, options = {}) {
+  const rawContent = await readFileSafely(filePath, { allowPathological: options.allowPathological, maxBytes: options.maxBytes });
+  const sample = rawContent.subarray(0, 1024 * 1024);
+  const detection = ContentTypeInterpreter.detectContentType(sample, path.extname(filePath));
+  let isBinary = ContentTypeInterpreter.isBinaryContent(sample, detection.mimeType);
+  if (options.forceBinary) isBinary = true;
+  let content = rawContent;
+  if (!isBinary) {
+    try {
+      content = new TextDecoder("utf-8", { fatal: true }).decode(rawContent);
+    } catch {
+      content = new TextDecoder("utf-8", { fatal: false }).decode(rawContent);
+    }
+  }
+  return {
+    content,
+    filename: path.basename(filePath),
+    mimeType: detection.mimeType,
+    extension: detection.extension,
+    isBinary,
+    size: rawContent.length
+  };
+}
+async function getTreeHashes(dirPath) {
+  const hashes = {};
+  const files = await listFiles(dirPath, true);
+  for (const filePath of files) {
+    const relPath = path.relative(dirPath, filePath);
+    try {
+      const result = await processFileContent(filePath);
+      const sha = crypto.createHash("sha256");
+      if (typeof result.content === "string") {
+        sha.update(result.content, "utf-8");
+      } else {
+        sha.update(result.content);
+      }
+      hashes[relPath] = sha.digest("hex");
+    } catch (e) {
+      console.warn(`Failed to hash ${filePath}:`, e);
+    }
+  }
+  return hashes;
+}
+
+// src/Loader.ts
+var DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
+var WRAP_WIDTH_KNOWN = 1e3;
+var WRAP_WIDTH_DEFAULT = 80;
+var Logger = {
+  info: (...args) => console.log("[Loader]", ...args),
+  warn: (...args) => console.warn("[Loader]", ...args),
+  error: (...args) => console.error("[Loader]", ...args),
+  debug: (...args) => {
+    if (process.env.DEBUG) console.log("[Loader]", ...args);
+  }
+};
+async function processAndStoreFile(filePath, collection, options = {}) {
+  const {
+    allowProblematic = false,
+    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
+    metadataOnly = false,
+    rootPath
+  } = options;
+  try {
+    let fileInfo;
+    if (await isProblematicFile(filePath)) {
+      if (!allowProblematic) {
+        Logger.warn(`Skipping problematic file: ${filePath}`);
+        return null;
+      }
+      const extension = path2.extname(filePath).toLowerCase();
+      const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(extension);
+      const wrapWidth = isKnownType ? WRAP_WIDTH_KNOWN : WRAP_WIDTH_DEFAULT;
+      Logger.warn(`Problematic file detected, processing as safe text: ${filePath}`);
+      try {
+        const streamed = await streamReadNormalizedText(filePath, {
+          byteCap: maxBytesOnProblem,
+          wrapWidth
+        });
+        fileInfo = {
+          content: streamed.text,
+          filename: path2.basename(filePath),
+          mimeType: "text/plain",
+          extension,
+          isBinary: false,
+          size: streamed.text.length,
+          originalSize: streamed.originalSize,
+          originalSha256Prefix: streamed.originalSha256Prefix,
+          normalized: true,
+          wrapWidth
+        };
+      } catch (e) {
+        Logger.warn(`Safe text processing failed, falling back to capped binary: ${filePath}`, e);
+        fileInfo = await processFileContent(filePath, {
+          forceBinary: true,
+          allowPathological: true,
+          maxBytes: maxBytesOnProblem
+        });
+      }
+    } else {
+      Logger.info(`Processing file: ${filePath}`);
+      fileInfo = await processFileContent(filePath);
+    }
+    if (!fileInfo) return null;
+    const content = fileInfo.content;
+    if (!content || typeof content === "string" && content.length === 0 || content instanceof Uint8Array && content.length === 0) {
+      Logger.debug(`Skipping empty file: ${filePath} (empty files cannot be stored as MCards)`);
+      return {
+        hash: "",
+        contentType: fileInfo.mimeType,
+        isBinary: fileInfo.isBinary,
+        filename: fileInfo.filename,
+        size: 0,
+        filePath
+      };
+    }
+    let mcard = null;
+    const isProblematic = await isProblematicFile(filePath);
+    if (metadataOnly && isProblematic) {
+      mcard = null;
+    } else {
+      mcard = await MCard.create(fileInfo.content);
+      const handle = path2.basename(filePath);
+      try {
+        await collection.addWithHandle(mcard, handle);
+      } catch (e) {
+        let registered = false;
+        if (rootPath) {
+          const relPath = path2.relative(rootPath, filePath);
+          if (relPath !== handle) {
+            try {
+              await collection.addWithHandle(mcard, relPath);
+              registered = true;
+            } catch (e2) {
+              Logger.debug(
+                `Handle name '${handle}' already in use (common for files like README.md, LICENSE). MCard stored successfully with hash ${mcard.hash.slice(0, 8)}... (accessible by hash, not by handle)`
+              );
+            }
+          }
+        }
+        if (!registered) {
+          try {
+            await collection.add(mcard);
+          } catch (e3) {
+            Logger.warn(`Hash fallback also failed for ${handle}:`, e3);
+          }
+        }
+      }
+    }
+    const result = {
+      hash: mcard ? mcard.hash : "METADATA_ONLY",
+      contentType: fileInfo.mimeType,
+      isBinary: fileInfo.isBinary,
+      filename: fileInfo.filename,
+      size: fileInfo.size,
+      filePath
+    };
+    if (fileInfo.originalSize !== void 0) result.originalSize = fileInfo.originalSize;
+    if (fileInfo.originalSha256Prefix) result.originalSha256Prefix = fileInfo.originalSha256Prefix;
+    if (metadataOnly && isProblematic) result.metadataOnly = true;
+    return result;
+  } catch (e) {
+    Logger.error(`Error processing ${filePath}:`, e);
+    return null;
+  }
+}
+async function loadFileToCollection(targetPath, collection, options = {}) {
+  const {
+    recursive = false,
+    includeProblematic = false,
+    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
+    metadataOnly = false
+  } = options;
+  const resolvedPath = path2.resolve(targetPath);
+  const stats = await fs2.stat(resolvedPath);
+  const results = [];
+  let files = [];
+  let rootPath = resolvedPath;
+  if (stats.isFile()) {
+    files = [resolvedPath];
+    rootPath = path2.dirname(resolvedPath);
+  } else if (stats.isDirectory()) {
+    files = await listFiles(resolvedPath, recursive);
+    rootPath = resolvedPath;
+  } else {
+    throw new Error(`Path ${targetPath} is not a file or directory`);
+  }
+  const uniqueDirs = /* @__PURE__ */ new Set();
+  let maxDepth = 0;
+  for (const file of files) {
+    const dir = path2.dirname(file);
+    if (dir.startsWith(rootPath)) {
+      uniqueDirs.add(dir);
+      const rel = path2.relative(rootPath, file);
+      const parts = rel.split(path2.sep);
+      const depth = parts.length - 1;
+      if (depth > maxDepth) maxDepth = depth;
+    }
+  }
+  const metrics = {
+    filesCount: files.length,
+    directoriesCount: uniqueDirs.size,
+    directoryLevels: maxDepth
+  };
+  Logger.info(`About to process ${files.length} files`);
+  for (const file of files) {
+    const result = await processAndStoreFile(file, collection, {
+      allowProblematic: includeProblematic,
+      maxBytesOnProblem,
+      metadataOnly,
+      rootPath
+    });
+    if (result) results.push(result);
+  }
+  return { metrics, results };
+}
+async function exportCollectionToDirectory(collection, targetDir) {
+  let exportedCount = 0;
+  let bytesWritten = 0;
+  const handles = await collection.getAllHandles();
+  for (const h of handles) {
+    const handlePath = h.handle;
+    const card = await collection.get(h.hash);
+    if (card) {
+      const absolutePath = path2.join(targetDir, handlePath);
+      await fs2.mkdir(path2.dirname(absolutePath), { recursive: true });
+      await fs2.writeFile(absolutePath, card.content);
+      bytesWritten += card.content.length;
+      exportedCount++;
+    }
+  }
+  return { exportedCount, bytesWritten };
+}
+
+export {
+  getTreeHashes,
+  FileIO_exports,
+  processAndStoreFile,
+  loadFileToCollection,
+  exportCollectionToDirectory,
+  Loader_exports
+};