aethel 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.6 (2026-04-05)
+
+- Optimize status and saveSnapshot performance: parallelize loadState, skip redundant fetches, increase hash concurrency
+
+## 0.3.5 (2026-04-05)
+
+- Add progress bars and spinners for all time-consuming CLI operations
+
 ## 0.3.4 (2026-04-05)
 
 - Add empty folder sync support between local and Google Drive

package/package.json

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

package/src/cli.js

@@ -31,6 +31,7 @@ import {
   DuplicateFoldersError,
 } from "./core/drive-api.js";
 import { createDefaultIgnoreFile, loadIgnoreRules } from "./core/ignore.js";
+import { createProgressBar, createSpinner } from "./core/progress.js";
 import { Repository } from "./core/repository.js";
 import { runTui } from "./tui/index.js";
 
@@ -42,16 +43,36 @@ function addAuthOptions(command) {
     .option("--token <path>", "Path to cached OAuth token JSON");
 }
 
-async function openRepo(options, { requireWorkspace = true } = {}) {
+async function openRepo(options, { requireWorkspace = true, silent = false } = {}) {
   const root = requireWorkspace ? requireRoot() : null;
   const repo = new Repository(root, {
     credentials: options.credentials,
     token: options.token,
   });
-  await repo.connect();
+  const spinner = silent ? null : createSpinner("Connecting to Google Drive...");
+  try {
+    await repo.connect();
+    spinner?.succeed("Connected to Google Drive");
+  } catch (err) {
+    spinner?.fail("Connection failed");
+    throw err;
+  }
   return repo;
 }
 
+async function loadStateWithProgress(repo, opts) {
+  const spinner = createSpinner("Loading workspace state...");
+  try {
+    const state = await repo.loadState(opts);
+    const n = state.diff.changes.length;
+    spinner.succeed(n ? `Loaded state — ${n} change(s) detected` : "Loaded state — everything up to date");
+    return state;
+  } catch (err) {
+    spinner.fail("Failed to load workspace state");
+    throw err;
+  }
+}
+
 function matchesPattern(targetPath, pattern) {
   if (targetPath === pattern) {
     return true;
@@ -117,7 +138,9 @@ function requireConfirmation(options) {
 
 async function handleAuth(options) {
   const repo = await openRepo(options, { requireWorkspace: false });
+  const spinner = createSpinner("Fetching account info...");
   const account = await repo.getAccountInfo();
+  spinner.succeed(`Authenticated as ${account.email}`);
 
   const credentialsPath = resolveCredentialsPath(options.credentials);
   await persistCredentials(credentialsPath);
@@ -134,7 +157,9 @@ async function handleAuth(options) {
 async function handleClean(options) {
   requireConfirmation(options);
   const repo = await openRepo(options, { requireWorkspace: false });
+  const spinner = createSpinner("Listing remote files...");
   const files = await repo.listRemoteFiles({ includeSharedDrives: Boolean(options.sharedDrives) });
+  spinner.succeed(`Found ${files.length} file(s) on Drive`);
 
   printCleanerPlan(files, options);
 
@@ -148,13 +173,15 @@ async function handleClean(options) {
     return;
   }
 
+  const bar = createProgressBar(`Cleaning ${files.length} file(s)`, files.length);
   const result = await repo.batchOperateFiles(files, {
     permanent: Boolean(options.permanent),
     includeSharedDrives: Boolean(options.sharedDrives),
-    onProgress: (done, total, verb, name) => {
-      console.log(`[${done}/${total}] ${verb}: ${name}`);
+    onProgress: (done) => {
+      bar.update(done);
     },
   });
+  bar.done(`Cleaned ${files.length} file(s)`);
 
   if (result.errors) {
     console.log(`Completed with ${result.errors} error(s) out of ${files.length} file(s).`);
@@ -171,8 +198,9 @@ async function handleInit(options) {
   // Interactive folder selection when no --drive-folder is provided
   if (!driveFolderId) {
     const repo = await openRepo(options, { requireWorkspace: false });
-    console.log("Fetching root-level Drive folders...");
+    const spinner = createSpinner("Fetching root-level Drive folders...");
     const folders = await repo.listRootFolders();
+    spinner.succeed(`Found ${folders.length} folder(s) in Drive root`);
 
     if (folders.length === 0) {
       console.log("No folders found in Drive root. Syncing entire My Drive.");
@@ -225,7 +253,7 @@ async function handleInit(options) {
 
 async function handleStatus(options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const staged = repo.getStagedEntries();
 
   if (diff.isClean && staged.length === 0) {
@@ -264,7 +292,7 @@ async function handleStatus(options) {
 
 async function handleDiff(options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
 
   if (diff.isClean) {
     console.log("No changes detected.");
@@ -298,7 +326,7 @@ async function handleDiff(options) {
 
 async function handleAdd(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
 
   if (options.all) {
     const toStage = diff.changes.filter(
@@ -357,7 +385,7 @@ function handleReset(paths, options) {
   }
 }
 
-async function handleCommit(options, { repo: existingRepo } = {}) {
+async function handleCommit(options, { repo: existingRepo, snapshotHint } = {}) {
   const repo = existingRepo || await openRepo(options);
   const staged = repo.getStagedEntries();
 
@@ -367,25 +395,24 @@ async function handleCommit(options, { repo: existingRepo } = {}) {
   }
 
   const message = options.message || "sync";
+  const bar = createProgressBar(`Syncing ${staged.length} change(s)`, staged.length);
 
-  console.log(`Committing ${staged.length} change(s)...`);
-
-  const result = await repo.executeStaged((done, total, verb, name) => {
-    if (done < total) {
-      console.log(`  [${done + 1}/${total}] ${verb}: ${name}`);
-    }
+  const result = await repo.executeStaged((done) => {
+    bar.update(done + 1);
   });
 
-  console.log(`\nCommit complete: ${result.summary}`);
+  bar.done(`Commit complete: ${result.summary}`);
   if (result.errors.length) {
     for (const error of result.errors) {
       console.log(`  ERROR: ${error}`);
     }
   }
 
-  console.log("Saving snapshot...");
-  await repo.saveSnapshot(message);
-  console.log(`Snapshot saved: "${message}"`);
+  const spinner = createSpinner("Saving snapshot...");
+  // snapshotHint lets callers (pull/push) pass pre-loaded state
+  // so saveSnapshot skips redundant API calls / fs scans.
+  await repo.saveSnapshot(message, snapshotHint);
+  spinner.succeed(`Snapshot saved: "${message}"`);
 }
 
 function handleLog(options) {
@@ -409,10 +436,10 @@ async function handleFetch(options) {
   const repo = await openRepo(options);
 
   repo.invalidateRemoteCache();
-  console.log("Fetching remote file list...");
+  const spinner = createSpinner("Fetching remote file list...");
   const remoteState = await repo.getRemoteState({ useCache: false });
   const remote = remoteState.files;
-  console.log(`Found ${remote.length} file(s) on Drive.`);
+  spinner.succeed(`Found ${remote.length} file(s) on Drive`);
 
   const snapshot = repo.getSnapshot();
   if (snapshot) {
@@ -445,7 +472,7 @@ async function handleFetch(options) {
 
 async function handlePull(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState({ useCache: false });
+  const { diff, remoteState } = await loadStateWithProgress(repo, { useCache: false });
 
   let remoteChanges = diff.changes.filter((change) =>
     [
@@ -489,12 +516,16 @@ async function handlePull(paths, options) {
 
   const count = repo.stageChanges(remoteChanges);
   console.log(`Staged ${count} remote change(s). Committing...`);
-  await handleCommit({ ...options, message: options.message || "pull" }, { repo });
+  // Pull downloads remote→local: remote state unchanged, only re-scan local
+  await handleCommit({ ...options, message: options.message || "pull" }, {
+    repo,
+    snapshotHint: { remote: remoteState },
+  });
 }
 
 async function handlePush(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState({ useCache: false });
+  const { diff, local } = await loadStateWithProgress(repo, { useCache: false });
 
   let localChanges = diff.changes.filter((change) =>
     [
@@ -538,12 +569,16 @@ async function handlePush(paths, options) {
 
   const count = repo.stageChanges(localChanges);
   console.log(`Staged ${count} local change(s). Committing...`);
-  await handleCommit({ ...options, message: options.message || "push" }, { repo });
+  // Push uploads local→remote: local state unchanged, only re-fetch remote
+  await handleCommit({ ...options, message: options.message || "push" }, {
+    repo,
+    snapshotHint: { local },
+  });
 }
 
 async function handleResolve(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const conflicts = diff.conflicts;
 
   if (conflicts.length === 0) {
@@ -719,7 +754,7 @@ async function handleRestore(paths, options) {
     }
 
     const localDest = path.join(root, entry.localPath || entry.path);
-    console.log(`  Restoring ${targetPath} from Drive...`);
+    const spinner = createSpinner(`Restoring ${targetPath}...`);
 
     try {
       const meta = await repo.drive.files.get({
@@ -729,16 +764,16 @@ async function handleRestore(paths, options) {
 
       const { downloadFile } = await import("./core/drive-api.js");
       await downloadFile(repo.drive, { ...meta.data, id: entry.id }, localDest);
-      console.log(`  Restored: ${targetPath}`);
+      spinner.succeed(`Restored: ${targetPath}`);
     } catch (err) {
-      console.log(`  Failed to restore ${targetPath}: ${err.message}`);
+      spinner.fail(`Failed to restore ${targetPath}: ${err.message}`);
     }
   }
 }
 
 async function handleRm(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const root = repo.root;
 
   for (const targetPath of paths) {
@@ -784,7 +819,7 @@ async function handleMv(source, dest, options) {
 }
 
 async function handleTui(options) {
-  const repo = await openRepo(options, { requireWorkspace: false });
+  const repo = await openRepo(options, { requireWorkspace: false, silent: true });
   const cliArgs = [];
   if (options.credentials) {
     cliArgs.push("--credentials", options.credentials);
@@ -819,6 +854,7 @@ async function handleDedupeFolders(options) {
   const config = repo.getConfig();
   const rootFolderId = config.drive_folder_id || null;
   const ignoreRules = loadIgnoreRules(repo.root);
+  const dedupeSpinner = createSpinner("Scanning for duplicate folders...");
   const result = await dedupeDuplicateFolders(repo.drive, rootFolderId, {
     execute: Boolean(options.execute),
     ignoreRules,
@@ -848,8 +884,9 @@ async function handleDedupeFolders(options) {
     },
   });
 
+  dedupeSpinner.succeed(`Scan complete — ${result.duplicateFolders.length} duplicate group(s) found`);
+
   if (result.duplicateFolders.length === 0) {
-    console.log("No duplicate folders detected.");
     return;
   }
 

package/src/core/config.js

@@ -113,5 +113,6 @@ export function writeSnapshot(root, snapshot) {
     fs.copyFileSync(latest, path.join(snapDir, HISTORY_DIR, `${ts}.json`));
   }
 
-  fs.writeFileSync(latest, JSON.stringify(snapshot, null, 2) + "\n");
+  // Compact JSON — snapshots can be large, pretty-printing is slow + wastes disk
+  fs.writeFileSync(latest, JSON.stringify(snapshot) + "\n");
 }

package/src/core/progress.js

@@ -0,0 +1,90 @@
+/**
+ * Lightweight terminal progress indicators (spinner + bar).
+ * Writes to stderr so stdout stays clean for piped output.
+ */
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL = 80;
+const BAR_WIDTH = 25;
+
+const isTTY = process.stderr.isTTY;
+
+function clearLine() {
+  if (isTTY) process.stderr.write("\r\x1b[K");
+}
+
+export function createSpinner(message) {
+  if (!isTTY) {
+    process.stderr.write(`${message}\n`);
+    return {
+      update() {},
+      succeed(msg) { if (msg) process.stderr.write(`${msg}\n`); },
+      fail(msg) { if (msg) process.stderr.write(`${msg}\n`); },
+      stop() {},
+    };
+  }
+
+  let frame = 0;
+  let currentMessage = message;
+
+  const timer = setInterval(() => {
+    clearLine();
+    process.stderr.write(`${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${currentMessage}`);
+    frame++;
+  }, SPINNER_INTERVAL);
+
+  return {
+    update(msg) { currentMessage = msg; },
+    succeed(msg) {
+      clearInterval(timer);
+      clearLine();
+      process.stderr.write(`✔ ${msg || currentMessage}\n`);
+    },
+    fail(msg) {
+      clearInterval(timer);
+      clearLine();
+      process.stderr.write(`✖ ${msg || currentMessage}\n`);
+    },
+    stop() {
+      clearInterval(timer);
+      clearLine();
+    },
+  };
+}
+
+export function createProgressBar(label, total) {
+  let lastRendered = -1;
+
+  function render(current) {
+    if (current === lastRendered) return;
+    lastRendered = current;
+
+    const ratio = total > 0 ? Math.min(current / total, 1) : 0;
+    const filled = Math.round(BAR_WIDTH * ratio);
+    const empty = BAR_WIDTH - filled;
+    const pct = Math.round(ratio * 100);
+    const bar = "█".repeat(filled) + "░".repeat(empty);
+    const line = `${label} [${bar}] ${current}/${total} (${pct}%)`;
+
+    if (isTTY) {
+      clearLine();
+      process.stderr.write(line);
+    }
+  }
+
+  // Initial render
+  render(0);
+
+  return {
+    update(current) { render(current); },
+    done(msg) {
+      render(total);
+      if (isTTY) {
+        clearLine();
+        process.stderr.write(`✔ ${msg || label}\n`);
+      } else {
+        process.stderr.write(`${msg || label}\n`);
+      }
+    },
+  };
+}

package/src/core/remote-cache.js

@@ -45,6 +45,7 @@ export function readRemoteCache(root, rootFolderId = null, ttlMs = DEFAULT_TTL_M
 
 export function writeRemoteCache(root, remoteState, rootFolderId = null) {
   const p = cachePath(root);
+  // Compact JSON — cache can be large with many files
   fs.writeFileSync(
     p,
     JSON.stringify({

package/src/core/repository.js

@@ -112,17 +112,19 @@ export class Repository {
   async loadState({ useCache = true } = {}) {
     const config = this.getConfig();
 
-    const [local, snapshot] = await Promise.all([
+    // Run all three in parallel — remote fetch is the slowest, overlap it
+    // with local scan and snapshot read.
+    const [local, snapshot, remoteState] = await Promise.all([
       scanLocal(this._root),
       Promise.resolve(readLatestSnapshot(this._root)),
+      this._loadRemoteState({ useCache }),
     ]);
-
-    const remoteState = await this._loadRemoteState({ useCache });
     const remote = remoteState.files;
 
     return {
       config,
       remote,
+      remoteState,
       local,
       snapshot,
       diff: computeDiff(snapshot, remote, local, { root: this._root }),
@@ -178,20 +180,31 @@ export class Repository {
   }
 
   /**
-   * Invalidate cache, re-fetch remote + re-scan local, write snapshot.
+   * Build and persist a new snapshot.
+   *
+   * @param {string} message
+   * @param {object} [preloaded]
+   * @param {object} [preloaded.remote]  Reuse this remote state (skip API call)
+   * @param {object} [preloaded.local]   Reuse this local scan  (skip fs walk)
    */
-  async saveSnapshot(message = "sync") {
+  async saveSnapshot(message = "sync", { remote, local } = {}) {
     const config = this.getConfig();
     const rootFolderId = config.drive_folder_id || null;
 
-    invalidateRemoteCache(this._root);
-    const [remoteState, local] = await Promise.all([
-      getRemoteState(this.drive, rootFolderId),
-      scanLocal(this._root),
+    // Only fetch what wasn't pre-loaded, in parallel.
+    const needRemote = !remote;
+    const needLocal = !local;
+
+    if (needRemote) invalidateRemoteCache(this._root);
+
+    const [remoteState, localFiles] = await Promise.all([
+      needRemote ? getRemoteState(this.drive, rootFolderId) : remote,
+      needLocal ? scanLocal(this._root) : local,
     ]);
+
     assertNoDuplicateFolders(remoteState.duplicateFolders);
     writeRemoteCache(this._root, remoteState, rootFolderId);
-    writeSnapshot(this._root, buildSnapshot(remoteState.files, local, message));
+    writeSnapshot(this._root, buildSnapshot(remoteState.files, localFiles, message));
   }
 
   // ── Cache management ────────────────────────────────────────────────

package/src/core/snapshot.js

@@ -42,7 +42,7 @@ function saveHashCache(root, cache) {
 
 // ── Scanning ─────────────────────────────────────────────────────────
 
-const PARALLEL_HASH_LIMIT = 32;
+const PARALLEL_HASH_LIMIT = 128;
 
 export async function scanLocal(root, { respectIgnore = true } = {}) {
   const resolvedRoot = path.resolve(root);
@@ -54,7 +54,8 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
   const filesToHash = [];
   // Track directories and their child counts to detect empty folders
   const dirChildCount = new Map();
-  const dirStats = new Map();
+  // Map relative dir path → absolute path (for deferred stat on empty dirs only)
+  const dirAbsPath = new Map();
 
   async function walk(currentPath) {
     let entries;
@@ -72,6 +73,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
     if (relativeDirPath !== null) {
       if (!dirChildCount.has(relativeDirPath)) {
         dirChildCount.set(relativeDirPath, 0);
+        dirAbsPath.set(relativeDirPath, currentPath);
       }
     }
 
@@ -110,12 +112,6 @@ 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([
@@ -171,16 +167,24 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
     }
   }
 
-  for (const dirPath of emptyDirs) {
-    const stat = dirStats.get(dirPath);
+  // Only stat the empty directories (not all directories)
+  await Promise.all([...emptyDirs].map(async (dirPath) => {
+    let mtime = new Date().toISOString();
+    const absPath = dirAbsPath.get(dirPath);
+    if (absPath) {
+      try {
+        const stat = await fs.promises.stat(absPath);
+        mtime = new Date(stat.mtimeMs).toISOString();
+      } catch { /* ignore */ }
+    }
     result[dirPath] = {
       localPath: dirPath,
       isFolder: true,
       size: 0,
       md5: null,
-      modifiedTime: stat ? new Date(stat.mtimeMs).toISOString() : new Date().toISOString(),
+      modifiedTime: mtime,
     };
-  }
+  }));
 
   // Persist updated cache
   saveHashCache(resolvedRoot, nextCache);