mohyung 0.1.0

package/dist/index.js

@@ -0,0 +1,804 @@
+// src/core/store.ts
+import Database from "better-sqlite3";
+var SCHEMA_VERSION = "1";
+var CREATE_TABLES_SQL = `
+-- Metadata
+CREATE TABLE IF NOT EXISTS metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+
+-- Package information
+CREATE TABLE IF NOT EXISTS packages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  version TEXT NOT NULL,
+  path TEXT NOT NULL,
+  UNIQUE(name, version, path)
+);
+
+-- Content-addressable blob storage
+CREATE TABLE IF NOT EXISTS blobs (
+  hash TEXT PRIMARY KEY,
+  content BLOB NOT NULL,
+  original_size INTEGER,
+  compressed_size INTEGER
+);
+
+-- Files per package
+CREATE TABLE IF NOT EXISTS files (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  package_id INTEGER REFERENCES packages(id),
+  relative_path TEXT NOT NULL,
+  blob_hash TEXT REFERENCES blobs(hash),
+  mode INTEGER,
+  mtime INTEGER,
+  UNIQUE(package_id, relative_path)
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_files_package ON files(package_id);
+CREATE INDEX IF NOT EXISTS idx_files_blob ON files(blob_hash);
+`;
+var Store = class {
+  /** better-sqlite3 database instance */
+  db;
+  /**
+   * Create Store instance
+   * @param dbPath - SQLite database file path
+   */
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.initSchema();
+  }
+  /** Initialize schema (create tables and set version) */
+  initSchema() {
+    this.db.exec(CREATE_TABLES_SQL);
+    this.setMetadata("schema_version", SCHEMA_VERSION);
+  }
+  /**
+   * Save metadata
+   * @param key - Metadata key
+   * @param value - Value to save
+   */
+  setMetadata(key, value) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)
+    `);
+    stmt.run(key, value);
+  }
+  /**
+   * Get metadata
+   * @param key - Metadata key
+   * @returns Stored value or null
+   */
+  getMetadata(key) {
+    const stmt = this.db.prepare(`SELECT value FROM metadata WHERE key = ?`);
+    const row = stmt.get(key);
+    return row?.value ?? null;
+  }
+  /**
+   * Insert package (returns ID only if already exists)
+   * @param pkg - Package information
+   * @returns Inserted package ID
+   */
+  insertPackage(pkg) {
+    const stmt = this.db.prepare(`
+      INSERT INTO packages (name, version, path) VALUES (?, ?, ?)
+      ON CONFLICT(name, version, path) DO UPDATE SET name = name
+      RETURNING id
+    `);
+    const result = stmt.get(pkg.name, pkg.version, pkg.path);
+    return result.id;
+  }
+  /**
+   * Get package by ID
+   * @param id - Package ID
+   * @returns Package info or null
+   */
+  getPackageById(id) {
+    const stmt = this.db.prepare(`SELECT * FROM packages WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      version: row.version,
+      path: row.path
+    };
+  }
+  /**
+   * Get all packages
+   * @returns All package list
+   */
+  getAllPackages() {
+    const stmt = this.db.prepare(`SELECT * FROM packages`);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      version: row.version,
+      path: row.path
+    }));
+  }
+  /**
+   * Check if blob exists
+   * @param hash - Blob hash
+   * @returns Whether blob exists
+   */
+  hasBlob(hash) {
+    const stmt = this.db.prepare(`SELECT 1 FROM blobs WHERE hash = ?`);
+    return stmt.get(hash) !== void 0;
+  }
+  /**
+   * Insert blob (ignore duplicates)
+   * @param blob - Blob information
+   */
+  insertBlob(blob) {
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO blobs (hash, content, original_size, compressed_size)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(blob.hash, blob.content, blob.originalSize, blob.compressedSize);
+  }
+  /**
+   * Get blob content by hash
+   * @param hash - Blob hash
+   * @returns Compressed blob content or null
+   */
+  getBlob(hash) {
+    const stmt = this.db.prepare(`SELECT content FROM blobs WHERE hash = ?`);
+    const row = stmt.get(hash);
+    return row?.content ?? null;
+  }
+  /**
+   * Get blob storage statistics
+   * @returns Blob count and size statistics
+   */
+  getBlobStats() {
+    const stmt = this.db.prepare(`
+      SELECT
+        COUNT(*) as count,
+        COALESCE(SUM(original_size), 0) as original,
+        COALESCE(SUM(compressed_size), 0) as compressed
+      FROM blobs
+    `);
+    const row = stmt.get();
+    return {
+      totalBlobs: row.count,
+      totalOriginalSize: row.original,
+      totalCompressedSize: row.compressed
+    };
+  }
+  /**
+   * Insert file record (update on conflict)
+   * @param file - File record information
+   */
+  insertFile(file) {
+    const stmt = this.db.prepare(`
+      INSERT INTO files (package_id, relative_path, blob_hash, mode, mtime)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(package_id, relative_path) DO UPDATE SET
+        blob_hash = excluded.blob_hash,
+        mode = excluded.mode,
+        mtime = excluded.mtime
+    `);
+    stmt.run(
+      file.packageId,
+      file.relativePath,
+      file.blobHash,
+      file.mode,
+      file.mtime
+    );
+  }
+  /**
+   * Get files by package ID
+   * @param packageId - Package ID
+   * @returns File records for the package
+   */
+  getFilesByPackage(packageId) {
+    const stmt = this.db.prepare(`
+      SELECT id, package_id, relative_path, blob_hash, mode, mtime
+      FROM files WHERE package_id = ?
+    `);
+    const rows = stmt.all(packageId);
+    return rows.map((row) => ({
+      id: row.id,
+      packageId: row.package_id,
+      relativePath: row.relative_path,
+      blobHash: row.blob_hash,
+      mode: row.mode,
+      mtime: row.mtime
+    }));
+  }
+  /**
+   * Get all files (with package path)
+   * @returns All file records
+   */
+  getAllFiles() {
+    const stmt = this.db.prepare(`
+      SELECT f.id, f.package_id, f.relative_path, f.blob_hash, f.mode, f.mtime, p.path as package_path
+      FROM files f
+      JOIN packages p ON f.package_id = p.id
+    `);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      packageId: row.package_id,
+      relativePath: row.relative_path,
+      blobHash: row.blob_hash,
+      mode: row.mode,
+      mtime: row.mtime,
+      packagePath: row.package_path
+    }));
+  }
+  /**
+   * Get total file count
+   * @returns Total number of files
+   */
+  getTotalFileCount() {
+    const stmt = this.db.prepare(`SELECT COUNT(*) as count FROM files`);
+    const row = stmt.get();
+    return row.count;
+  }
+  /**
+   * Execute work within transaction
+   * @param fn - Function to execute within transaction
+   * @returns Function execution result
+   */
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  /**
+   * Get prepared statement for bulk file insertion
+   * @returns Prepared statement for file insertion
+   */
+  prepareInsertFile() {
+    return this.db.prepare(`
+      INSERT INTO files (package_id, relative_path, blob_hash, mode, mtime)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(package_id, relative_path) DO UPDATE SET
+        blob_hash = excluded.blob_hash,
+        mode = excluded.mode,
+        mtime = excluded.mtime
+    `);
+  }
+  /**
+   * Get prepared statement for bulk blob insertion
+   * @returns Prepared statement for blob insertion
+   */
+  prepareInsertBlob() {
+    return this.db.prepare(`
+      INSERT OR IGNORE INTO blobs (hash, content, original_size, compressed_size)
+      VALUES (?, ?, ?, ?)
+    `);
+  }
+  /** Close database connection */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/core/scanner.ts
+import { readdir, stat, readFile } from "fs/promises";
+import { join, relative } from "path";
+import { existsSync } from "fs";
+async function parsePackageJson(pkgJsonPath) {
+  try {
+    const content = await readFile(pkgJsonPath, "utf8");
+    const pkg = JSON.parse(content);
+    return {
+      name: pkg.name || "unknown",
+      version: pkg.version || "0.0.0"
+    };
+  } catch {
+    return null;
+  }
+}
+function isPnpmStructure(nodeModulesPath) {
+  return existsSync(join(nodeModulesPath, ".pnpm"));
+}
+async function* walkDir(dir, baseDir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkDir(fullPath, baseDir);
+    } else if (entry.isFile()) {
+      const stats = await stat(fullPath);
+      yield {
+        relativePath: relative(baseDir, fullPath),
+        absolutePath: fullPath,
+        mode: stats.mode,
+        size: stats.size,
+        mtime: stats.mtimeMs
+      };
+    }
+  }
+}
+async function* findPackageDirs(nodeModulesPath) {
+  const entries = await readdir(nodeModulesPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === ".bin" || entry.name === ".cache" || entry.name === ".pnpm")
+      continue;
+    const fullPath = join(nodeModulesPath, entry.name);
+    if (entry.name.startsWith("@")) {
+      const scopedEntries = await readdir(fullPath, { withFileTypes: true });
+      for (const scopedEntry of scopedEntries) {
+        if (!scopedEntry.isDirectory()) continue;
+        yield {
+          path: join(fullPath, scopedEntry.name),
+          relativePath: join(entry.name, scopedEntry.name)
+        };
+      }
+    } else {
+      yield {
+        path: fullPath,
+        relativePath: entry.name
+      };
+    }
+  }
+}
+async function* findPnpmPackageDirs(nodeModulesPath) {
+  const pnpmPath = join(nodeModulesPath, ".pnpm");
+  const entries = await readdir(pnpmPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const fullPath = join(pnpmPath, entry.name);
+    const innerNodeModules = join(fullPath, "node_modules");
+    if (!existsSync(innerNodeModules)) continue;
+    const innerEntries = await readdir(innerNodeModules, {
+      withFileTypes: true
+    });
+    for (const innerEntry of innerEntries) {
+      if (!innerEntry.isDirectory()) continue;
+      if (innerEntry.name === ".bin") continue;
+      const pkgPath = join(innerNodeModules, innerEntry.name);
+      if (innerEntry.name.startsWith("@")) {
+        const scopedEntries = await readdir(pkgPath, {
+          withFileTypes: true
+        });
+        for (const scopedEntry of scopedEntries) {
+          if (!scopedEntry.isDirectory()) continue;
+          yield {
+            path: join(pkgPath, scopedEntry.name),
+            relativePath: `.pnpm/${entry.name}/node_modules/${innerEntry.name}/${scopedEntry.name}`
+          };
+        }
+      } else {
+        yield {
+          path: pkgPath,
+          relativePath: `.pnpm/${entry.name}/node_modules/${innerEntry.name}`
+        };
+      }
+    }
+  }
+}
+async function scanNodeModules(nodeModulesPath, onProgress) {
+  const usePnpm = isPnpmStructure(nodeModulesPath);
+  const packageDirs = [];
+  if (usePnpm) {
+    for await (const dir of findPnpmPackageDirs(nodeModulesPath)) {
+      packageDirs.push(dir);
+    }
+  } else {
+    for await (const dir of findPackageDirs(nodeModulesPath)) {
+      packageDirs.push(dir);
+    }
+  }
+  const scanPackages = async () => {
+    const packages = [];
+    let totalFiles = 0;
+    let totalSize = 0;
+    let packageCount = 0;
+    for (const { path: pkgPath, relativePath } of packageDirs) {
+      packageCount++;
+      onProgress?.(packageCount, packageDirs.length, relativePath);
+      const pkgJsonPath = join(pkgPath, "package.json");
+      const pkgInfo = await parsePackageJson(pkgJsonPath);
+      if (!pkgInfo) continue;
+      const files = [];
+      for await (const file of walkDir(pkgPath, pkgPath)) {
+        files.push(file);
+        totalFiles++;
+        totalSize += file.size;
+      }
+      packages.push({
+        name: pkgInfo.name,
+        version: pkgInfo.version,
+        path: relativePath,
+        files
+      });
+    }
+    return { packages, totalFiles, totalSize };
+  };
+  return scanPackages();
+}
+async function countFiles(nodeModulesPath) {
+  const countDir = async (dir) => {
+    const entries = await readdir(dir, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        count += await countDir(fullPath);
+      } else if (entry.isFile()) {
+        count++;
+      }
+    }
+    return count;
+  };
+  return countDir(nodeModulesPath);
+}
+
+// src/core/extractor.ts
+import { mkdir, writeFile, chmod } from "fs/promises";
+import { dirname, join as join2 } from "path";
+
+// src/utils/compression.ts
+import { gzipSync, gunzipSync } from "zlib";
+function compress(data, level = 6) {
+  return gzipSync(data, { level });
+}
+function decompress(data) {
+  return gunzipSync(data);
+}
+
+// src/utils/logger.ts
+import { consola } from "consola";
+var logger = {
+  pack: consola.withTag("pack"),
+  unpack: consola.withTag("unpack"),
+  status: consola.withTag("status"),
+  scan: consola.withTag("scan")
+};
+function createLogger(tag) {
+  return consola.withTag(tag);
+}
+
+// src/core/extractor.ts
+var log = logger.unpack;
+async function extractFiles(store, outputPath, onProgress) {
+  const files = store.getAllFiles();
+  const totalFiles = files.length;
+  const blobCache = /* @__PURE__ */ new Map();
+  const getContent = (blobHash) => {
+    if (blobCache.has(blobHash)) {
+      return blobCache.get(blobHash);
+    }
+    const compressed = store.getBlob(blobHash);
+    if (!compressed) return null;
+    const content = decompress(compressed);
+    if (content.length < 100 * 1024) {
+      blobCache.set(blobHash, content);
+    }
+    return content;
+  };
+  const iterateFiles = async () => {
+    let processedFiles = 0;
+    let totalSize2 = 0;
+    for (const file of files) {
+      processedFiles++;
+      onProgress?.(processedFiles, totalFiles, file.relativePath.slice(0, 40));
+      const fullPath = join2(outputPath, file.packagePath, file.relativePath);
+      await mkdir(dirname(fullPath), { recursive: true });
+      const content = getContent(file.blobHash);
+      if (!content) {
+        log.warn(`Blob not found: ${file.relativePath}`);
+        continue;
+      }
+      await writeFile(fullPath, content);
+      totalSize2 += content.length;
+      if (file.mode) {
+        try {
+          await chmod(fullPath, file.mode & 511);
+        } catch {
+        }
+      }
+    }
+    return { totalSize: totalSize2 };
+  };
+  const { totalSize } = await iterateFiles();
+  return {
+    totalFiles,
+    totalSize
+  };
+}
+
+// src/core/hasher.ts
+import { createHash } from "crypto";
+function hashBuffer(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function hashString(data) {
+  return createHash("sha256").update(data, "utf8").digest("hex");
+}
+
+// src/utils/progress.ts
+function createProgressBar(total) {
+  const startTime = Date.now();
+  return (current, actualTotal, message) => {
+    const t = actualTotal || total;
+    const ratio = t > 0 ? Math.min(current / t, 1) : 0;
+    const percent = Math.round(ratio * 100);
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    const barWidth = 30;
+    const filled = Math.max(0, Math.round(ratio * barWidth));
+    const empty = Math.max(0, barWidth - filled);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+    const line = `\r[${bar}] ${percent}% (${current}/${t}) ${elapsed}s${message ? ` - ${message}` : ""}`;
+    process.stdout.write(line);
+    if (current >= t) {
+      process.stdout.write("\n");
+    }
+  };
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+
+// src/commands/pack.ts
+import { readFile as readFile2, stat as stat2, rm } from "fs/promises";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join3, resolve } from "path";
+var log2 = logger.pack;
+async function pack(options) {
+  const { source, output, compressionLevel, includeLockfile } = options;
+  const nodeModulesPath = resolve(source);
+  const dbPath = resolve(output);
+  if (!existsSync2(nodeModulesPath)) {
+    throw new Error(`node_modules not found: ${nodeModulesPath}`);
+  }
+  log2.start(`Scanning ${nodeModulesPath}`);
+  const scanProgress = createProgressBar(100);
+  const scanResult = await scanNodeModules(
+    nodeModulesPath,
+    (current, total, msg) => {
+      scanProgress(current, total, msg);
+    }
+  );
+  log2.success(
+    `Found ${scanResult.packages.length} packages, ${scanResult.totalFiles} files (${formatBytes(scanResult.totalSize)})`
+  );
+  if (existsSync2(dbPath)) {
+    await rm(dbPath);
+    if (existsSync2(dbPath + "-wal")) await rm(dbPath + "-wal");
+    if (existsSync2(dbPath + "-shm")) await rm(dbPath + "-shm");
+  }
+  const store = new Store(dbPath);
+  store.setMetadata("created_at", (/* @__PURE__ */ new Date()).toISOString());
+  store.setMetadata("node_version", process.version);
+  store.setMetadata("source_path", nodeModulesPath);
+  if (includeLockfile) {
+    const lockfilePath = join3(nodeModulesPath, "..", "package-lock.json");
+    if (existsSync2(lockfilePath)) {
+      const lockfileContent = await readFile2(lockfilePath, "utf8");
+      store.setMetadata("lockfile_hash", hashString(lockfileContent));
+    }
+  }
+  log2.start("Packing files...");
+  const packProgress = createProgressBar(scanResult.totalFiles);
+  const insertBlob = store.prepareInsertBlob();
+  const insertFile = store.prepareInsertFile();
+  const packFiles = () => {
+    let processedFiles = 0;
+    let deduplicatedCount2 = 0;
+    for (const pkg of scanResult.packages) {
+      const packageId = store.insertPackage({
+        name: pkg.name,
+        version: pkg.version,
+        path: pkg.path
+      });
+      for (const file of pkg.files) {
+        processedFiles++;
+        packProgress(
+          processedFiles,
+          scanResult.totalFiles,
+          file.relativePath.slice(0, 40)
+        );
+        const content = readFileSync(file.absolutePath);
+        const hash = hashBuffer(content);
+        if (!store.hasBlob(hash)) {
+          const compressed = compress(content, compressionLevel);
+          insertBlob.run(hash, compressed, content.length, compressed.length);
+        } else {
+          deduplicatedCount2++;
+        }
+        insertFile.run(
+          packageId,
+          file.relativePath,
+          hash,
+          file.mode,
+          file.mtime
+        );
+      }
+    }
+    return { deduplicatedCount: deduplicatedCount2 };
+  };
+  const { deduplicatedCount } = store.transaction(packFiles);
+  store.close();
+  const dbStats = await stat2(dbPath);
+  const compressionRatio = ((1 - dbStats.size / scanResult.totalSize) * 100).toFixed(1);
+  log2.box({
+    title: "Pack Complete",
+    message: [
+      `Output: ${dbPath}`,
+      `Original: ${formatBytes(scanResult.totalSize)}`,
+      `DB size: ${formatBytes(dbStats.size)}`,
+      `Compression: ${compressionRatio}%`,
+      `Deduplicated: ${deduplicatedCount}`
+    ].join("\n"),
+    style: {
+      borderColor: "green"
+    }
+  });
+}
+
+// src/commands/unpack.ts
+import { existsSync as existsSync3 } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var log3 = logger.unpack;
+async function unpack(options) {
+  const { input, output, force } = options;
+  const dbPath = resolve2(input);
+  const outputPath = resolve2(output);
+  if (!existsSync3(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+  if (existsSync3(outputPath)) {
+    if (!force) {
+      throw new Error(
+        `Output directory already exists: ${outputPath}. Use --force to overwrite.`
+      );
+    }
+    log3.warn(`Removing existing ${outputPath}...`);
+    await rm2(outputPath, { recursive: true, force: true });
+  }
+  log3.info(`Opening ${dbPath}`);
+  const store = new Store(dbPath);
+  const createdAt = store.getMetadata("created_at");
+  const nodeVersion = store.getMetadata("node_version");
+  const totalFileCount = store.getTotalFileCount();
+  const blobStats = store.getBlobStats();
+  log3.box({
+    title: "Database Info",
+    message: [
+      `Created: ${createdAt ?? "unknown"}`,
+      `Node version: ${nodeVersion ?? "unknown"}`,
+      `Files: ${totalFileCount}`,
+      `Original size: ${formatBytes(blobStats.totalOriginalSize)}`,
+      `Compressed size: ${formatBytes(blobStats.totalCompressedSize)}`
+    ].join("\n")
+  });
+  log3.start(`Extracting to ${outputPath}`);
+  const progress = createProgressBar(totalFileCount);
+  const startTime = Date.now();
+  const result = await extractFiles(store, outputPath, progress);
+  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+  store.close();
+  log3.box({
+    title: "Unpack Complete",
+    message: [
+      `Extracted: ${result.totalFiles} files (${formatBytes(
+        result.totalSize
+      )})`,
+      `Time: ${elapsed}s`
+    ].join("\n"),
+    style: {
+      borderColor: "green"
+    }
+  });
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve3, join as join4 } from "path";
+var log4 = logger.status;
+async function status(options) {
+  const { db, nodeModules } = options;
+  const dbPath = resolve3(db);
+  const nodeModulesPath = resolve3(nodeModules);
+  if (!existsSync4(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+  if (!existsSync4(nodeModulesPath)) {
+    log4.warn(`node_modules not found: ${nodeModulesPath}`);
+    log4.info('Run "mohyung unpack" to restore from database.');
+    return { onlyInDb: [], onlyInFs: [], modified: [], unchanged: 0 };
+  }
+  log4.start("Comparing...");
+  log4.info(`DB: ${dbPath}`);
+  log4.info(`node_modules: ${nodeModulesPath}`);
+  const store = new Store(dbPath);
+  const files = store.getAllFiles();
+  const result = {
+    onlyInDb: [],
+    onlyInFs: [],
+    modified: [],
+    unchanged: 0
+  };
+  const progress = createProgressBar(files.length);
+  const dbPaths = /* @__PURE__ */ new Set();
+  for (const [index, file] of files.entries()) {
+    const relativePath = join4(file.packagePath, file.relativePath);
+    const fullPath = join4(nodeModulesPath, relativePath);
+    dbPaths.add(relativePath);
+    progress(index + 1, files.length, relativePath.slice(0, 40));
+    if (!existsSync4(fullPath)) {
+      result.onlyInDb.push(relativePath);
+      continue;
+    }
+    try {
+      const fsContent = await readFile3(fullPath);
+      const fsHash = hashBuffer(fsContent);
+      if (fsHash !== file.blobHash) {
+        result.modified.push(relativePath);
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.modified.push(relativePath);
+    }
+  }
+  store.close();
+  const summaryLines = [
+    `Unchanged: ${result.unchanged}`,
+    `Modified: ${result.modified.length}`,
+    `Only in DB: ${result.onlyInDb.length}`
+  ];
+  if (result.modified.length > 0 && result.modified.length <= 10) {
+    summaryLines.push("", "Modified files:");
+    result.modified.forEach((f) => summaryLines.push(`  M ${f}`));
+  }
+  if (result.onlyInDb.length > 0 && result.onlyInDb.length <= 10) {
+    summaryLines.push("", "Only in DB (deleted locally):");
+    result.onlyInDb.forEach((f) => summaryLines.push(`  D ${f}`));
+  }
+  if (result.modified.length > 10 || result.onlyInDb.length > 10) {
+    summaryLines.push("", "(Use verbose mode for full list)");
+  }
+  const isClean = result.modified.length === 0 && result.onlyInDb.length === 0;
+  log4.box({
+    title: "Status",
+    message: summaryLines.join("\n"),
+    style: {
+      borderColor: isClean ? "green" : "yellow"
+    }
+  });
+  if (isClean) {
+    log4.success("All files match!");
+  }
+  return result;
+}
+export {
+  Store,
+  compress,
+  consola,
+  countFiles,
+  createLogger,
+  createProgressBar,
+  decompress,
+  extractFiles,
+  formatBytes,
+  hashBuffer,
+  hashString,
+  logger,
+  pack,
+  scanNodeModules,
+  status,
+  unpack
+};
+//# sourceMappingURL=index.js.map