aethel 0.3.5 → 0.3.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.7 (2026-04-05)
+
+- Fix orphan checker not recognizing My Drive root — all files under synced folders were silently dropped
+
+## 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

package/package.json

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

package/src/cli.js

@@ -60,12 +60,36 @@ async function openRepo(options, { requireWorkspace = true, silent = false } = {
   return repo;
 }
 
+function fmtMs(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
+}
+
 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");
+    const state = await repo.loadState({
+      ...opts,
+      onPhase(phase, ms) {
+        if (phase === "local") spinner.update(`Scanned local files (${fmtMs(ms)}), waiting for remote...`);
+        else if (phase === "remote") spinner.update(`Fetched remote state (${fmtMs(ms)}), computing diff...`);
+      },
+    });
+    const { timings, diff } = state;
+    const n = diff.changes.length;
+
+    const parts = [
+      `${timings.localFiles} local`,
+      `${timings.remoteFiles} remote`,
+    ];
+    const times = [
+      `scan ${fmtMs(timings.localMs)}`,
+      timings.remoteCached ? `remote cache hit` : `fetch ${fmtMs(timings.remoteMs)}`,
+      `diff ${fmtMs(timings.diffMs)}`,
+      `total ${fmtMs(timings.totalMs)}`,
+    ];
+
+    const summary = n ? `${n} change(s)` : "up to date";
+    spinner.succeed(`${summary} (${parts.join(", ")}) [${times.join(" | ")}]`);
     return state;
   } catch (err) {
     spinner.fail("Failed to load workspace state");
@@ -385,7 +409,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();
 
@@ -408,9 +432,16 @@ async function handleCommit(options, { repo: existingRepo } = {}) {
     }
   }
 
+  const snapshotStart = Date.now();
   const spinner = createSpinner("Saving snapshot...");
-  await repo.saveSnapshot(message);
-  spinner.succeed(`Snapshot saved: "${message}"`);
+  // snapshotHint lets callers (pull/push) pass pre-loaded state
+  // so saveSnapshot skips redundant API calls / fs scans.
+  await repo.saveSnapshot(message, snapshotHint);
+  const skipped = [];
+  if (snapshotHint?.remote) skipped.push("remote reused");
+  if (snapshotHint?.local) skipped.push("local reused");
+  const hint = skipped.length ? ` (${skipped.join(", ")})` : "";
+  spinner.succeed(`Snapshot saved in ${fmtMs(Date.now() - snapshotStart)}${hint}`);
 }
 
 function handleLog(options) {
@@ -434,10 +465,11 @@ async function handleFetch(options) {
   const repo = await openRepo(options);
 
   repo.invalidateRemoteCache();
+  const fetchStart = Date.now();
   const spinner = createSpinner("Fetching remote file list...");
   const remoteState = await repo.getRemoteState({ useCache: false });
   const remote = remoteState.files;
-  spinner.succeed(`Found ${remote.length} file(s) on Drive`);
+  spinner.succeed(`Found ${remote.length} file(s) on Drive [${fmtMs(Date.now() - fetchStart)}]`);
 
   const snapshot = repo.getSnapshot();
   if (snapshot) {
@@ -470,7 +502,7 @@ async function handleFetch(options) {
 
 async function handlePull(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await loadStateWithProgress(repo, { useCache: false });
+  const { diff, remoteState } = await loadStateWithProgress(repo, { useCache: false });
 
   let remoteChanges = diff.changes.filter((change) =>
     [
@@ -514,12 +546,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 loadStateWithProgress(repo, { useCache: false });
+  const { diff, local } = await loadStateWithProgress(repo, { useCache: false });
 
   let localChanges = diff.changes.filter((change) =>
     [
@@ -563,7 +599,11 @@ 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) {

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/drive-api.js

@@ -226,6 +226,15 @@ async function fetchAllItems(drive, { fields, includeSharedDrives = false } = {}
   const files = [];
   let pageToken = null;
 
+  // Fetch the real My Drive root folder metadata in parallel with
+  // the main list.  Google Drive API returns actual folder IDs in
+  // `parents` (e.g. "0AJ…"), NOT the alias "root".  Without this,
+  // the orphan checker can't recognise the root and marks every
+  // top-level folder as orphaned — silently dropping all files.
+  const rootPromise = drive.files
+    .get({ fileId: "root", fields: "id,name,mimeType,parents,createdTime" })
+    .catch(() => null);
+
   const listOpts = {
     q: "trashed = false",
     fields: allFields,
@@ -252,6 +261,12 @@ async function fetchAllItems(drive, { fields, includeSharedDrives = false } = {}
     pageToken = response.data.nextPageToken;
   } while (pageToken);
 
+  // Add the real root folder so the orphan checker can walk up to it.
+  const rootRes = await rootPromise;
+  if (rootRes?.data?.id) {
+    folders.set(rootRes.data.id, rootRes.data);
+  }
+
   return { folders, files };
 }
 

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

@@ -109,23 +109,48 @@ export class Repository {
    * Load full workspace state in parallel, replacing the old
    * loadWorkspaceState() helper from cli.js.
    */
-  async loadState({ useCache = true } = {}) {
+  async loadState({ useCache = true, onPhase } = {}) {
     const config = this.getConfig();
-
-    const [local, snapshot] = await Promise.all([
-      scanLocal(this._root),
-      Promise.resolve(readLatestSnapshot(this._root)),
+    const t0 = Date.now();
+
+    // Run all three in parallel — remote fetch is the slowest, overlap it
+    // with local scan and snapshot read.
+    const timings = {};
+
+    const [local, snapshot, remoteState] = await Promise.all([
+      scanLocal(this._root).then((r) => {
+        timings.localMs = Date.now() - t0;
+        onPhase?.("local", timings.localMs);
+        return r;
+      }),
+      Promise.resolve(readLatestSnapshot(this._root)).then((r) => {
+        timings.snapshotMs = Date.now() - t0;
+        return r;
+      }),
+      this._loadRemoteState({ useCache }).then((r) => {
+        timings.remoteMs = Date.now() - t0;
+        timings.remoteCached = useCache && timings.remoteMs < 100;
+        onPhase?.("remote", timings.remoteMs);
+        return r;
+      }),
     ]);
-
-    const remoteState = await this._loadRemoteState({ useCache });
     const remote = remoteState.files;
 
+    const diffStart = Date.now();
+    const diff = computeDiff(snapshot, remote, local, { root: this._root });
+    timings.diffMs = Date.now() - diffStart;
+    timings.totalMs = Date.now() - t0;
+    timings.localFiles = Object.keys(local).length;
+    timings.remoteFiles = remote.length;
+
     return {
       config,
       remote,
+      remoteState,
       local,
       snapshot,
-      diff: computeDiff(snapshot, remote, local, { root: this._root }),
+      diff,
+      timings,
     };
   }
 
@@ -178,20 +203,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);