aethel 0.3.3 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.3.4 (2026-04-05)
+
+- Add empty folder sync support between local and Google Drive
+
 ## 0.3.3 (2026-04-05)
 
 - Persist credentials to ~/.config/aethel/ after auth for seamless init

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aethel",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Git-style Google Drive sync CLI with interactive TUI",
   "type": "module",
   "license": "MIT",

package/src/core/diff.js

@@ -87,6 +87,11 @@ function buildDiffResult(changes) {
 }
 
 function remoteChanged(snapshotEntry, remoteEntry) {
+  // Folders don't change — only their existence matters
+  if (remoteEntry.isFolder || remoteEntry.mimeType === "application/vnd.google-apps.folder") {
+    return false;
+  }
+
   if (isWorkspaceType(remoteEntry.mimeType || "")) {
     return snapshotEntry.modifiedTime !== remoteEntry.modifiedTime;
   }
@@ -95,6 +100,8 @@ function remoteChanged(snapshotEntry, remoteEntry) {
 }
 
 function localChanged(snapshotEntry, localEntry) {
+  // Folders don't change — only their existence matters
+  if (localEntry.isFolder) return false;
   return snapshotEntry.md5 !== localEntry.md5;
 }
 
@@ -153,6 +160,21 @@ function promoteConflicts(changes) {
  * @param {object} localFiles
  * @param {{ root?: string, respectIgnore?: boolean }} options
  */
+/**
+ * Collect all implicit folder paths from a set of file paths.
+ * e.g. "a/b/c.txt" → {"a", "a/b"}
+ */
+function collectFolderPaths(filePaths) {
+  const folders = new Set();
+  for (const p of filePaths) {
+    const parts = p.split("/");
+    for (let i = 1; i < parts.length; i++) {
+      folders.add(parts.slice(0, i).join("/"));
+    }
+  }
+  return folders;
+}
+
 export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIgnore = true } = {}) {
   const ignoreRules = root && respectIgnore ? loadIgnoreRules(root) : null;
 
@@ -164,6 +186,19 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   const snapshotFiles = snapshot?.files || {};
   const snapshotLocalFiles = snapshot?.localFiles || {};
 
+  // 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));
+
+  // 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)) {
+    if (meta.isFolder) localFolderPaths.add(p);
+  }
+
   // Build remote lookup and detect additions/modifications in one pass
   const remoteById = new Map();
   for (const remoteFile of remoteFiles) {
@@ -171,6 +206,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     const snapshotEntry = snapshotFiles[remoteFile.id];
 
     if (!snapshotEntry) {
+      // Skip remote folder if it already exists locally (as parent or explicit dir)
+      if (remoteFile.isFolder && localFolderPaths.has(remoteFile.path)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.REMOTE_ADDED,
@@ -199,6 +238,11 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   for (const fileId of Object.keys(snapshotFiles)) {
     if (!remoteById.has(fileId)) {
       const snapshotEntry = snapshotFiles[fileId];
+      // Skip folder deletion if the folder still implicitly exists on Drive
+      // (e.g. it became non-empty, or was recreated with a different ID)
+      if (snapshotEntry.isFolder && remoteFolderPaths.has(snapshotEntry.path || snapshotEntry.localPath || "")) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.REMOTE_DELETED,
@@ -214,6 +258,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     const snapshotEntry = snapshotLocalFiles[relativePath];
 
     if (!snapshotEntry) {
+      // Skip local folder if it already exists on Drive (as parent or explicit dir)
+      if (localMeta.isFolder && remoteFolderPaths.has(relativePath)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_ADDED,
@@ -238,6 +286,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
 
   for (const [relativePath, snapshotEntry] of Object.entries(snapshotLocalFiles)) {
     if (!(relativePath in localFiles)) {
+      // Skip folder deletion if the folder still implicitly exists locally
+      if (snapshotEntry.isFolder && localFolderPaths.has(relativePath)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_DELETED,

package/src/core/drive-api.js

@@ -302,6 +302,10 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
   const resolve = createFolderResolver(folders, rootFolderId);
   const isOrphaned = createOrphanChecker(folders);
   const files = [];
+
+  // Track which folders have children (files or subfolders)
+  const foldersWithChildren = new Set();
+
   for (const file of rawFiles) {
     const parentId = file.parents?.[0] || "";
 
@@ -312,6 +316,9 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
 
     if (rootFolderId && parentPath === null) continue;
 
+    // Mark parent as having children
+    if (parentId) foldersWithChildren.add(parentId);
+
     files.push({
       id: file.id,
       name: file.name,
@@ -322,6 +329,34 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
       md5Checksum: file.md5Checksum || null,
     });
   }
+
+  // Mark folders that have subfolders as children
+  for (const folder of folders.values()) {
+    const parentId = folder.parents?.[0] || "";
+    if (parentId) foldersWithChildren.add(parentId);
+  }
+
+  // Include empty folders (no file children AND no subfolder children)
+  for (const folder of folders.values()) {
+    if (foldersWithChildren.has(folder.id)) continue;
+    if (isOrphaned(folder.id)) continue;
+
+    const folderPath = resolve(folder.id);
+    if (rootFolderId && folderPath === null) continue;
+    if (!folderPath) continue; // skip root-level marker
+
+    files.push({
+      id: folder.id,
+      name: folder.name,
+      path: folderPath,
+      mimeType: FOLDER_MIME,
+      size: null,
+      modifiedTime: folder.modifiedTime || null,
+      md5Checksum: null,
+      isFolder: true,
+    });
+  }
+
   return files;
 }
 

package/src/core/snapshot.js

@@ -52,6 +52,9 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
 
   // Phase 1: collect all file stats (fast — no hashing yet)
   const filesToHash = [];
+  // Track directories and their child counts to detect empty folders
+  const dirChildCount = new Map();
+  const dirStats = new Map();
 
   async function walk(currentPath) {
     let entries;
@@ -61,8 +64,20 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       return;
     }
 
+    const relativeDirPath = currentPath === resolvedRoot
+      ? null
+      : path.relative(resolvedRoot, currentPath).split(path.sep).join("/");
+
+    // Register this directory (skip root itself)
+    if (relativeDirPath !== null) {
+      if (!dirChildCount.has(relativeDirPath)) {
+        dirChildCount.set(relativeDirPath, 0);
+      }
+    }
+
     const subdirs = [];
     const statPromises = [];
+    let trackedChildren = 0;
 
     for (const entry of entries) {
       const fullPath = path.join(currentPath, entry.name);
@@ -76,6 +91,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       }
 
       if (entry.isDirectory()) {
+        trackedChildren++;
         subdirs.push(fullPath);
         continue;
       }
@@ -84,6 +100,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
         continue;
       }
 
+      trackedChildren++;
       statPromises.push(
         fs.promises.stat(fullPath).then((stat) => {
           filesToHash.push({ fullPath, relativePath, stat });
@@ -91,6 +108,16 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       );
     }
 
+    if (relativeDirPath !== null) {
+      dirChildCount.set(relativeDirPath, trackedChildren);
+      try {
+        const stat = await fs.promises.stat(currentPath);
+        dirStats.set(relativeDirPath, stat);
+      } catch {
+        // ignore
+      }
+    }
+
     await Promise.all([
       ...statPromises,
       ...subdirs.map((dir) => walk(dir)),
@@ -121,6 +148,40 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
     }
   }
 
+  // Phase 3: detect empty folders (directories with zero tracked children)
+  // Walk bottom-up: a dir is "empty" if it has no tracked children AND
+  // all its subdirectories are also empty.
+  const emptyDirs = new Set();
+  // Sort by depth (deepest first) for bottom-up processing
+  const sortedDirs = [...dirChildCount.keys()].sort(
+    (a, b) => b.split("/").length - a.split("/").length
+  );
+
+  for (const dirPath of sortedDirs) {
+    const childCount = dirChildCount.get(dirPath);
+    if (childCount === 0) {
+      emptyDirs.add(dirPath);
+      // Propagate: decrement parent's tracked child count since this child is empty
+      const parentDir = dirPath.includes("/")
+        ? dirPath.slice(0, dirPath.lastIndexOf("/"))
+        : null;
+      if (parentDir && dirChildCount.has(parentDir)) {
+        dirChildCount.set(parentDir, dirChildCount.get(parentDir) - 1);
+      }
+    }
+  }
+
+  for (const dirPath of emptyDirs) {
+    const stat = dirStats.get(dirPath);
+    result[dirPath] = {
+      localPath: dirPath,
+      isFolder: true,
+      size: 0,
+      md5: null,
+      modifiedTime: stat ? new Date(stat.mtimeMs).toISOString() : new Date().toISOString(),
+    };
+  }
+
   // Persist updated cache
   saveHashCache(resolvedRoot, nextCache);
   return result;
@@ -158,6 +219,7 @@ export function buildSnapshot(remoteFiles, localFiles, message = "") {
       mimeType: file.mimeType || "",
       modifiedTime: file.modifiedTime ?? null,
       localPath: file.path,
+      ...(file.isFolder ? { isFolder: true } : {}),
     };
   }
 

package/src/core/staging.js

@@ -19,6 +19,11 @@ function changeToEntry(change) {
     entry.remotePath = change.remoteMeta.path;
   }
 
+  // Propagate folder flag so sync knows to create folder instead of uploading file
+  if (change.localMeta?.isFolder || change.remoteMeta?.isFolder) {
+    entry.isFolder = true;
+  }
+
   return entry;
 }
 

package/src/core/sync.js

@@ -20,6 +20,7 @@ export class CommitResult {
     this.uploaded = 0;
     this.deletedLocal = 0;
     this.deletedRemote = 0;
+    this.foldersCreated = 0;
     this.errors = [];
   }
 
@@ -28,7 +29,8 @@ export class CommitResult {
       this.downloaded +
       this.uploaded +
       this.deletedLocal +
-      this.deletedRemote
+      this.deletedRemote +
+      this.foldersCreated
     );
   }
 
@@ -41,6 +43,9 @@ export class CommitResult {
     if (this.uploaded) {
       parts.push(`${this.uploaded} uploaded`);
     }
+    if (this.foldersCreated) {
+      parts.push(`${this.foldersCreated} folders created`);
+    }
     if (this.deletedLocal) {
       parts.push(`${this.deletedLocal} deleted locally`);
     }
@@ -56,9 +61,16 @@ export class CommitResult {
 }
 
 async function downloadStagedFile(drive, entry, root) {
-  const fileId = entry.fileId;
   const localRelativePath = entry.localPath || entry.path;
   const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
+
+  // Empty folder: just create the directory locally
+  if (entry.isFolder) {
+    fs.mkdirSync(localAbsolutePath, { recursive: true });
+    return;
+  }
+
+  const fileId = entry.fileId;
   const response = await drive.files.get({
     fileId,
     fields: "id,name,mimeType",
@@ -69,9 +81,16 @@ async function downloadStagedFile(drive, entry, root) {
 
 async function uploadStagedFile(drive, entry, root, driveFolderId) {
   const localRelativePath = entry.localPath || entry.path;
-  const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
   const remotePath = entry.remotePath || entry.path;
 
+  // Empty folder: just ensure it exists on Drive
+  if (entry.isFolder) {
+    await ensureFolder(drive, remotePath, driveFolderId);
+    return;
+  }
+
+  const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
+
   if (!fs.existsSync(localAbsolutePath)) {
     throw new Error(`Local file not found: ${localAbsolutePath}`);
   }
@@ -97,18 +116,25 @@ async function deleteLocalFile(entry, root) {
     return;
   }
 
-  await fs.promises.unlink(localAbsolutePath);
+  // Empty folder: remove the directory itself
+  if (entry.isFolder) {
+    await fs.promises.rmdir(localAbsolutePath).catch(() => {});
+  } else {
+    await fs.promises.unlink(localAbsolutePath);
+  }
 
-  let currentPath = path.dirname(localAbsolutePath);
+  // Clean up empty parent directories up to workspace root
+  let currentPath = entry.isFolder ? localAbsolutePath : path.dirname(localAbsolutePath);
   const resolvedRoot = path.resolve(root);
 
   while (currentPath !== resolvedRoot) {
-    const contents = await fs.promises.readdir(currentPath);
-    if (contents.length > 0) {
+    try {
+      const contents = await fs.promises.readdir(currentPath);
+      if (contents.length > 0) break;
+      await fs.promises.rmdir(currentPath);
+    } catch {
       break;
     }
-
-    await fs.promises.rmdir(currentPath);
     currentPath = path.dirname(currentPath);
   }
 }
@@ -195,10 +221,12 @@ export async function executeStaged(drive, root, progress) {
       const action = entry.action;
       if (action === "download") {
         await downloadStagedFile(drive, entry, root);
-        result.downloaded++;
+        if (entry.isFolder) result.foldersCreated++;
+        else result.downloaded++;
       } else if (action === "upload") {
         await uploadStagedFile(drive, entry, root, driveFolderId);
-        result.uploaded++;
+        if (entry.isFolder) result.foldersCreated++;
+        else result.uploaded++;
       } else if (action === "delete_remote") {
         await deleteRemoteFile(drive, entry);
         result.deletedRemote++;