aethel 1.0.0 → 1.2.1

package/src/core/config.js

@@ -5,6 +5,8 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import YAML from "yaml";
+import { createManifest } from "./pack-manifest.js";
 
 export const AETHEL_DIR = ".aethel";
 export const CONFIG_FILE = "config.json";
@@ -12,6 +14,8 @@ export const INDEX_FILE = "index.json";
 export const SNAPSHOTS_DIR = "snapshots";
 export const HISTORY_DIR = "history";
 export const LATEST_SNAPSHOT = "latest.json";
+export const PACK_MANIFEST_FILE = "pack-manifest.json";
+export const PACK_CONFIG_FILE = ".aethelconfig";
 
 /** Walk up from `start` looking for a .aethel/ directory. */
 export function findRoot(start = process.cwd()) {
@@ -135,3 +139,118 @@ export function writeSnapshot(root, snapshot) {
   // Compact JSON — snapshots can be large, pretty-printing is slow + wastes disk
   fs.writeFileSync(latest, JSON.stringify(snapshot) + "\n");
 }
+
+// ── pack config helpers ───────────────────────────────────────────────
+
+const DEFAULT_PACK_CONFIG = {
+  packing: {
+    enabled: false,
+    compression: {
+      default: {
+        algorithm: "zstd",
+        level: 6,
+      },
+      overrides: [],
+    },
+    rules: [],
+  },
+};
+
+/**
+ * Load pack configuration from .aethelconfig (YAML).
+ * Returns default config if file doesn't exist.
+ * @param {string} root - Workspace root
+ * @returns {object} Pack configuration
+ */
+export function loadPackConfig(root) {
+  const p = path.join(root, PACK_CONFIG_FILE);
+  if (!fs.existsSync(p)) {
+    return structuredClone(DEFAULT_PACK_CONFIG);
+  }
+  try {
+    const content = fs.readFileSync(p, "utf-8");
+    const parsed = YAML.parse(content);
+    // Merge with defaults for missing keys
+    return {
+      packing: {
+        ...DEFAULT_PACK_CONFIG.packing,
+        ...parsed?.packing,
+        compression: {
+          ...DEFAULT_PACK_CONFIG.packing.compression,
+          ...parsed?.packing?.compression,
+        },
+      },
+    };
+  } catch {
+    return structuredClone(DEFAULT_PACK_CONFIG);
+  }
+}
+
+/**
+ * Save pack configuration to .aethelconfig.
+ * @param {string} root - Workspace root
+ * @param {object} config - Configuration to save
+ */
+export function savePackConfig(root, config) {
+  const p = path.join(root, PACK_CONFIG_FILE);
+  const content = YAML.stringify(config);
+  fs.writeFileSync(p, content);
+}
+
+/**
+ * Read pack manifest from .aethel/pack-manifest.json.
+ * Returns empty manifest if file doesn't exist.
+ * @param {string} root - Workspace root
+ * @returns {object} Pack manifest
+ */
+export function loadPackManifest(root) {
+  const p = path.join(dot(root), PACK_MANIFEST_FILE);
+  if (!fs.existsSync(p)) {
+    return createManifest();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return createManifest();
+  }
+}
+
+/**
+ * Save pack manifest to .aethel/pack-manifest.json.
+ * @param {string} root - Workspace root
+ * @param {object} manifest - Manifest to save
+ */
+export function savePackManifest(root, manifest) {
+  const p = path.join(dot(root), PACK_MANIFEST_FILE);
+  fs.writeFileSync(p, JSON.stringify(manifest, null, 2) + "\n");
+}
+
+/**
+ * Check if packing feature is enabled.
+ * @param {string} root - Workspace root
+ * @returns {boolean}
+ */
+export function isPackingEnabled(root) {
+  const config = loadPackConfig(root);
+  return config.packing?.enabled === true;
+}
+
+/**
+ * Get packing rule for a specific path.
+ * @param {object} packConfig - Pack configuration
+ * @param {string} relativePath - Path to check
+ * @returns {object|null} Matching rule or null
+ */
+export function getPackRule(packConfig, relativePath) {
+  const rules = packConfig.packing?.rules ?? [];
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+
+  for (const rule of rules) {
+    const rulePath = rule.path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+    if (normalized === rulePath || normalized.startsWith(rulePath + "/")) {
+      return rule;
+    }
+  }
+
+  return null;
+}

package/src/core/diff.js

@@ -1,5 +1,6 @@
 import { isWorkspaceType } from "./drive-api.js";
 import { loadIgnoreRules } from "./ignore.js";
+import { loadPackManifest } from "./config.js";
 
 export const ChangeType = Object.freeze({
   REMOTE_ADDED: "remote_added",
@@ -9,6 +10,12 @@ export const ChangeType = Object.freeze({
   LOCAL_MODIFIED: "local_modified",
   LOCAL_DELETED: "local_deleted",
   CONFLICT: "conflict",
+  // Pack-specific change types
+  PACK_LOCAL_MODIFIED: "pack_local_modified",
+  PACK_REMOTE_MODIFIED: "pack_remote_modified",
+  PACK_SYNCED: "pack_synced",
+  PACK_CONFLICT: "pack_conflict",
+  PACK_NEW: "pack_new",
 });
 
 const SHORT_STATUS = {
@@ -19,6 +26,11 @@ const SHORT_STATUS = {
   [ChangeType.LOCAL_MODIFIED]: "ML",
   [ChangeType.LOCAL_DELETED]: "-L",
   [ChangeType.CONFLICT]: "!!",
+  [ChangeType.PACK_LOCAL_MODIFIED]: "PL",
+  [ChangeType.PACK_REMOTE_MODIFIED]: "PR",
+  [ChangeType.PACK_SYNCED]: "P=",
+  [ChangeType.PACK_CONFLICT]: "P!",
+  [ChangeType.PACK_NEW]: "P+",
 };
 
 const DESCRIPTION = {
@@ -29,6 +41,11 @@ const DESCRIPTION = {
   [ChangeType.LOCAL_MODIFIED]: "modified locally",
   [ChangeType.LOCAL_DELETED]: "deleted locally",
   [ChangeType.CONFLICT]: "both sides changed",
+  [ChangeType.PACK_LOCAL_MODIFIED]: "pack changed locally",
+  [ChangeType.PACK_REMOTE_MODIFIED]: "pack changed on Drive",
+  [ChangeType.PACK_SYNCED]: "pack up to date",
+  [ChangeType.PACK_CONFLICT]: "pack conflict",
+  [ChangeType.PACK_NEW]: "new pack",
 };
 
 const SUGGESTED_ACTION = {
@@ -39,6 +56,11 @@ const SUGGESTED_ACTION = {
   [ChangeType.LOCAL_MODIFIED]: "upload",
   [ChangeType.LOCAL_DELETED]: "delete_remote",
   [ChangeType.CONFLICT]: "conflict",
+  [ChangeType.PACK_LOCAL_MODIFIED]: "push_pack",
+  [ChangeType.PACK_REMOTE_MODIFIED]: "pull_pack",
+  [ChangeType.PACK_SYNCED]: "none",
+  [ChangeType.PACK_CONFLICT]: "resolve_pack",
+  [ChangeType.PACK_NEW]: "push_pack",
 };
 
 function createChange({
@@ -62,9 +84,10 @@ function createChange({
   };
 }
 
-function buildDiffResult(changes) {
+function buildDiffResult(changes, packChanges = []) {
   return {
     changes,
+    packChanges,
     get remoteChanges() {
       return this.changes.filter((change) =>
         change.changeType.startsWith("remote")
@@ -80,8 +103,29 @@ function buildDiffResult(changes) {
         (change) => change.changeType === ChangeType.CONFLICT
       );
     },
+    get packConflicts() {
+      return this.packChanges.filter(
+        (change) => change.changeType === ChangeType.PACK_CONFLICT
+      );
+    },
+    get pendingPackChanges() {
+      return this.packChanges.filter(
+        (change) =>
+          change.changeType === ChangeType.PACK_LOCAL_MODIFIED ||
+          change.changeType === ChangeType.PACK_REMOTE_MODIFIED ||
+          change.changeType === ChangeType.PACK_NEW
+      );
+    },
+    get syncedPacks() {
+      return this.packChanges.filter(
+        (change) => change.changeType === ChangeType.PACK_SYNCED
+      );
+    },
+    get hasPackChanges() {
+      return this.pendingPackChanges.length > 0 || this.packConflicts.length > 0;
+    },
     get isClean() {
-      return this.changes.length === 0;
+      return this.changes.length === 0 && this.pendingPackChanges.length === 0;
     },
   };
 }
@@ -154,6 +198,93 @@ function promoteConflicts(changes) {
   return filtered;
 }
 
+/**
+ * Compute pack-level changes by comparing local packedDirs against manifest.
+ * @param {string|null} root - Workspace root for loading manifest
+ * @param {object} packedDirs - Local packed directories from scanLocal
+ * @param {object|null} snapshot - Previous snapshot (may contain packedDirs)
+ * @returns {object[]} Array of pack change objects
+ */
+function computePackChanges(root, packedDirs, snapshot) {
+  if (!root || !packedDirs || Object.keys(packedDirs).length === 0) {
+    return [];
+  }
+
+  const manifest = loadPackManifest(root);
+  const snapshotPackedDirs = snapshot?.packedDirs || {};
+  const changes = [];
+
+  for (const [packPath, packInfo] of Object.entries(packedDirs)) {
+    const manifestEntry = manifest.packs?.[packPath];
+    const snapshotEntry = snapshotPackedDirs[packPath];
+    const localTreeHash = packInfo.treeHash;
+
+    if (!manifestEntry) {
+      // Pack not in manifest = new pack
+      changes.push(
+        createChange({
+          changeType: ChangeType.PACK_NEW,
+          path: packPath,
+          localMeta: packInfo,
+        })
+      );
+      continue;
+    }
+
+    const { localTreeHash: manifestLocalHash, remoteTreeHash: manifestRemoteHash } = manifestEntry;
+
+    // Check for local modification
+    const localChanged = localTreeHash !== manifestLocalHash;
+    // Check for remote modification (comparing against what we last synced)
+    const remoteChanged = manifestRemoteHash && manifestRemoteHash !== manifestLocalHash;
+
+    if (localChanged && remoteChanged) {
+      // Both sides changed = conflict
+      changes.push(
+        createChange({
+          changeType: ChangeType.PACK_CONFLICT,
+          path: packPath,
+          localMeta: { ...packInfo, treeHash: localTreeHash },
+          snapshotMeta: { treeHash: manifestLocalHash },
+          remoteMeta: { treeHash: manifestRemoteHash },
+        })
+      );
+    } else if (localChanged) {
+      // Only local changed
+      changes.push(
+        createChange({
+          changeType: ChangeType.PACK_LOCAL_MODIFIED,
+          path: packPath,
+          localMeta: { ...packInfo, treeHash: localTreeHash },
+          snapshotMeta: { treeHash: manifestLocalHash },
+        })
+      );
+    } else if (remoteChanged) {
+      // Only remote changed
+      changes.push(
+        createChange({
+          changeType: ChangeType.PACK_REMOTE_MODIFIED,
+          path: packPath,
+          localMeta: packInfo,
+          remoteMeta: { treeHash: manifestRemoteHash },
+          snapshotMeta: { treeHash: manifestLocalHash },
+        })
+      );
+    } else {
+      // No changes = synced
+      changes.push(
+        createChange({
+          changeType: ChangeType.PACK_SYNCED,
+          path: packPath,
+          localMeta: packInfo,
+        })
+      );
+    }
+  }
+
+  return changes;
+}
+
 /**
  * @param {object|null} snapshot
  * @param {object[]} remoteFiles
@@ -175,6 +306,20 @@ function collectFolderPaths(filePaths) {
   return folders;
 }
 
+function indexSnapshotFilesByPath(snapshotFiles) {
+  const byPath = new Map();
+
+  for (const [fileId, entry] of Object.entries(snapshotFiles || {})) {
+    for (const pathValue of [entry.path, entry.localPath]) {
+      if (pathValue && !byPath.has(pathValue)) {
+        byPath.set(pathValue, { fileId, entry });
+      }
+    }
+  }
+
+  return byPath;
+}
+
 export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIgnore = true } = {}) {
   const ignoreRules = root && respectIgnore ? loadIgnoreRules(root) : null;
 
@@ -182,20 +327,26 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   if (ignoreRules) {
     remoteFiles = remoteFiles.filter((f) => !ignoreRules.ignores(f.path));
   }
+
+  // Handle new localFiles format with .files and .packedDirs
+  const localFilesData = localFiles?.files ?? localFiles;
+  const packedDirs = localFiles?.packedDirs ?? {};
+
   const changes = [];
   const snapshotFiles = snapshot?.files || {};
   const snapshotLocalFiles = snapshot?.localFiles || {};
+  const snapshotRemoteByPath = indexSnapshotFilesByPath(snapshotFiles);
 
   // Build sets of all folder paths that implicitly exist on each side
   // (from parent directories of files), so we can skip redundant folder additions.
   const remoteFolderPaths = collectFolderPaths(remoteFiles.map((f) => f.path));
-  const localFolderPaths = collectFolderPaths(Object.keys(localFiles));
+  const localFolderPaths = collectFolderPaths(Object.keys(localFilesData));
 
   // Also include explicit folder entries
   for (const f of remoteFiles) {
     if (f.isFolder) remoteFolderPaths.add(f.path);
   }
-  for (const [p, meta] of Object.entries(localFiles)) {
+  for (const [p, meta] of Object.entries(localFilesData)) {
     if (meta.isFolder) localFolderPaths.add(p);
   }
 
@@ -254,7 +405,7 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     }
   }
 
-  for (const [relativePath, localMeta] of Object.entries(localFiles)) {
+  for (const [relativePath, localMeta] of Object.entries(localFilesData)) {
     const snapshotEntry = snapshotLocalFiles[relativePath];
 
     if (!snapshotEntry) {
@@ -273,10 +424,12 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     }
 
     if (localChanged(snapshotEntry, localMeta)) {
+      const remoteEntry = snapshotRemoteByPath.get(relativePath);
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_MODIFIED,
           path: relativePath,
+          fileId: remoteEntry?.fileId || null,
           localMeta,
           snapshotMeta: snapshotEntry,
         })
@@ -285,20 +438,25 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   }
 
   for (const [relativePath, snapshotEntry] of Object.entries(snapshotLocalFiles)) {
-    if (!(relativePath in localFiles)) {
+    if (!(relativePath in localFilesData)) {
       // Skip folder deletion if the folder still implicitly exists locally
       if (snapshotEntry.isFolder && localFolderPaths.has(relativePath)) {
         continue;
       }
+      const remoteEntry = snapshotRemoteByPath.get(relativePath);
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_DELETED,
           path: relativePath,
+          fileId: remoteEntry?.fileId || null,
           snapshotMeta: snapshotEntry,
         })
       );
     }
   }
 
-  return buildDiffResult(promoteConflicts(changes));
+  // Compute pack changes
+  const packChanges = computePackChanges(root, packedDirs, snapshot);
+
+  return buildDiffResult(promoteConflicts(changes), packChanges);
 }

package/src/core/pack-manifest.js

@@ -0,0 +1,163 @@
+/**
+ * Pack manifest CRUD operations.
+ * Manages the pack-manifest.json data structure.
+ */
+
+import crypto from "node:crypto";
+
+const MANIFEST_VERSION = 1;
+
+/**
+ * Create a new empty manifest.
+ * @returns {{ version: number, packs: {} }}
+ */
+export function createManifest() {
+  return {
+    version: MANIFEST_VERSION,
+    packs: {},
+  };
+}
+
+/**
+ * Get pack information for a specific path.
+ * @param {object} manifest - Manifest object
+ * @param {string} packPath - Directory path (e.g., "node_modules")
+ * @returns {object|null} Pack info or null if not found
+ */
+export function getPack(manifest, packPath) {
+  const normalized = normalizePath(packPath);
+  return manifest.packs[normalized] ?? null;
+}
+
+/**
+ * Set or update pack information.
+ * @param {object} manifest - Manifest object
+ * @param {string} packPath - Directory path
+ * @param {object} data - Pack data to set/merge
+ * @returns {object} Updated manifest
+ */
+export function setPack(manifest, packPath, data) {
+  const normalized = normalizePath(packPath);
+  const existing = manifest.packs[normalized] ?? {};
+
+  manifest.packs[normalized] = {
+    ...existing,
+    ...data,
+    // Always update lastModified when setting
+    lastModified: new Date().toISOString(),
+  };
+
+  return manifest;
+}
+
+/**
+ * Remove a pack from the manifest.
+ * @param {object} manifest - Manifest object
+ * @param {string} packPath - Directory path
+ * @returns {object} Updated manifest
+ */
+export function removePack(manifest, packPath) {
+  const normalized = normalizePath(packPath);
+  delete manifest.packs[normalized];
+  return manifest;
+}
+
+/**
+ * List all packs in the manifest.
+ * @param {object} manifest - Manifest object
+ * @returns {Array<{ path: string, info: object }>}
+ */
+export function listPacks(manifest) {
+  return Object.entries(manifest.packs).map(([path, info]) => ({
+    path,
+    info,
+  }));
+}
+
+/**
+ * Check if a path is covered by any pack rule.
+ * @param {object} manifest - Manifest object
+ * @param {string} filePath - File path to check
+ * @returns {{ isPacked: boolean, packPath: string|null }}
+ */
+export function isPathPacked(manifest, filePath) {
+  const normalized = normalizePath(filePath);
+
+  for (const packPath of Object.keys(manifest.packs)) {
+    // Check if filePath starts with packPath
+    if (normalized === packPath || normalized.startsWith(packPath + "/")) {
+      return { isPacked: true, packPath };
+    }
+  }
+
+  return { isPacked: false, packPath: null };
+}
+
+/**
+ * Validate manifest structure.
+ * @param {object} manifest - Manifest to validate
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateManifest(manifest) {
+  const errors = [];
+
+  if (!manifest || typeof manifest !== "object") {
+    errors.push("Manifest must be an object");
+    return { valid: false, errors };
+  }
+
+  if (typeof manifest.version !== "number") {
+    errors.push("Manifest version must be a number");
+  }
+
+  if (manifest.version !== MANIFEST_VERSION) {
+    errors.push(`Unsupported manifest version: ${manifest.version} (expected ${MANIFEST_VERSION})`);
+  }
+
+  if (!manifest.packs || typeof manifest.packs !== "object") {
+    errors.push("Manifest packs must be an object");
+  } else {
+    for (const [path, info] of Object.entries(manifest.packs)) {
+      if (typeof path !== "string" || path.length === 0) {
+        errors.push(`Invalid pack path: ${path}`);
+      }
+      if (!info || typeof info !== "object") {
+        errors.push(`Pack info for "${path}" must be an object`);
+      } else {
+        if (!info.packId || typeof info.packId !== "string") {
+          errors.push(`Pack "${path}" missing valid packId`);
+        }
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Generate a unique pack ID.
+ * @param {string} packPath - Directory path
+ * @returns {string} Pack ID like "pack-node_modules-a1b2c3d4"
+ */
+export function generatePackId(packPath) {
+  const normalized = normalizePath(packPath);
+  // Sanitize path for ID: replace / with _ and remove special chars
+  const sanitized = normalized
+    .replace(/\//g, "_")
+    .replace(/[^a-zA-Z0-9_-]/g, "");
+  const shortHash = crypto.randomBytes(4).toString("hex");
+  return `pack-${sanitized}-${shortHash}`;
+}
+
+/**
+ * Normalize a path for consistent manifest keys.
+ * @param {string} p - Path to normalize
+ * @returns {string}
+ */
+function normalizePath(p) {
+  // Remove leading/trailing slashes and normalize to forward slashes
+  return p
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/\/+$/, "");
+}