aethel 0.2.6 → 0.3.1

package/src/core/auth.js

@@ -1,8 +1,8 @@
 import fs from "node:fs/promises";
 import fsSyncFallback from "node:fs";
 import http from "node:http";
+import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { URL } from "node:url";
 import { google } from "googleapis";
 import open from "open";
@@ -10,8 +10,7 @@ import open from "open";
 const SCOPES = ["https://www.googleapis.com/auth/drive"];
 const DEFAULT_CREDENTIALS_PATH = "credentials.json";
 const DEFAULT_TOKEN_PATH = "token.json";
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = path.resolve(MODULE_DIR, "..", "..");
+const CONFIG_DIR = path.join(os.homedir(), ".config", "aethel");
 const AUTH_TIMEOUT_MS = 120_000;
 
 // ── Path resolution ─────────────────────────────────────────────────
@@ -22,7 +21,12 @@ function resolvePath(candidatePath, fallbackFileName) {
       ? candidatePath
       : path.resolve(process.cwd(), candidatePath);
   }
-  return path.join(PROJECT_ROOT, fallbackFileName);
+  // Also check cwd before falling back to ~/.config/aethel/
+  const cwdPath = path.resolve(process.cwd(), fallbackFileName);
+  if (fsSyncFallback.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+  return path.join(CONFIG_DIR, fallbackFileName);
 }
 
 export function resolveCredentialsPath(customPath) {
@@ -47,7 +51,15 @@ async function loadClientConfig(credentialsPath) {
     raw = await fs.readFile(credentialsPath, "utf8");
   } catch {
     throw new Error(
-      `OAuth credentials file was not found. Expected path: ${credentialsPath}`
+      `OAuth credentials file not found: ${credentialsPath}\n\n` +
+      "Setup steps:\n" +
+      "  1. Go to https://console.cloud.google.com/\n" +
+      "  2. Create a project and enable the Google Drive API\n" +
+      "  3. Create an OAuth 2.0 Client ID (Desktop application)\n" +
+      "  4. Download the credentials JSON and save it as:\n" +
+      `     ${path.join(CONFIG_DIR, DEFAULT_CREDENTIALS_PATH)}\n\n` +
+      "Or pass a custom path:\n" +
+      "  aethel auth --credentials /path/to/credentials.json"
     );
   }
 

package/src/core/diff.js

@@ -163,16 +163,12 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   const changes = [];
   const snapshotFiles = snapshot?.files || {};
   const snapshotLocalFiles = snapshot?.localFiles || {};
-  const snapshotById = new Map();
-
-  for (const [fileId, meta] of Object.entries(snapshotFiles)) {
-    snapshotById.set(fileId, meta);
-  }
-
-  const remoteById = new Map(remoteFiles.map((file) => [file.id, file]));
 
+  // Build remote lookup and detect additions/modifications in one pass
+  const remoteById = new Map();
   for (const remoteFile of remoteFiles) {
-    const snapshotEntry = snapshotById.get(remoteFile.id);
+    remoteById.set(remoteFile.id, remoteFile);
+    const snapshotEntry = snapshotFiles[remoteFile.id];
 
     if (!snapshotEntry) {
       changes.push(
@@ -199,8 +195,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     }
   }
 
-  for (const [fileId, snapshotEntry] of snapshotById.entries()) {
+  // Detect remote deletions — snapshot entries missing from remote
+  for (const fileId of Object.keys(snapshotFiles)) {
     if (!remoteById.has(fileId)) {
+      const snapshotEntry = snapshotFiles[fileId];
       changes.push(
         createChange({
           changeType: ChangeType.REMOTE_DELETED,

package/src/core/drive-api.js

@@ -255,11 +255,59 @@ async function fetchAllItems(drive, { fields, includeSharedDrives = false } = {}
   return { folders, files };
 }
 
+/**
+ * Build a cached orphan checker. A folder is "orphaned" if its parent
+ * chain leads to a trashed/inaccessible folder rather than "root".
+ *
+ * When a folder is trashed, Google Drive does NOT mark its children as
+ * trashed. They remain `trashed = false` but their parent is gone from
+ * our fetched folder map, making them "orphaned".
+ */
+function createOrphanChecker(folders) {
+  const cache = new Map();
+
+  return function isOrphaned(folderId) {
+    if (cache.has(folderId)) return cache.get(folderId);
+
+    // Walk the chain, collecting unresolved IDs
+    const pending = [];
+    let current = folderId;
+
+    while (current) {
+      if (current === "root") {
+        for (const id of pending) cache.set(id, false);
+        return false;
+      }
+      if (cache.has(current)) {
+        const result = cache.get(current);
+        for (const id of pending) cache.set(id, result);
+        return result;
+      }
+      pending.push(current);
+      const folder = folders.get(current);
+      if (!folder) {
+        for (const id of pending) cache.set(id, true);
+        return true;
+      }
+      current = folder.parents?.[0] || "";
+    }
+
+    // No parent — root-level
+    for (const id of pending) cache.set(id, false);
+    return false;
+  };
+}
+
 function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
   const resolve = createFolderResolver(folders, rootFolderId);
+  const isOrphaned = createOrphanChecker(folders);
   const files = [];
   for (const file of rawFiles) {
     const parentId = file.parents?.[0] || "";
+
+    // Skip files whose parent folder was trashed (orphaned children)
+    if (parentId && isOrphaned(parentId)) continue;
+
     const parentPath = parentId === rootFolderId ? "" : resolve(parentId);
 
     if (rootFolderId && parentPath === null) continue;
@@ -646,26 +694,21 @@ export async function listAccessibleFiles(drive, includeSharedDrives = false) {
     includeSharedDrives,
   });
 
-  // Build resolver from the folders already collected
-  const pathCache = new Map();
-  function resolveFolderPath(folderId) {
-    if (pathCache.has(folderId)) return pathCache.get(folderId);
-    if (!folderId) { pathCache.set(folderId, ""); return ""; }
-    const folder = folders.get(folderId);
-    if (!folder) { pathCache.set(folderId, ""); return ""; }
-    const parentPath = resolveFolderPath(folder.parents?.[0] || "");
-    const result = parentPath ? path.posix.join(parentPath, folder.name) : folder.name;
-    pathCache.set(folderId, result);
-    return result;
-  }
+  const resolveFolderPath = createFolderResolver(folders, null);
+  const isOrphaned = createOrphanChecker(folders);
 
   // Combine folders + files into result list (TUI needs folders too)
+  // Filter out orphaned items (children of trashed folders)
   const allItems = [...folders.values(), ...rawItems];
   const result = [];
 
   for (const file of allItems) {
     const parentId = file.parents?.[0] || "";
-    const parentPath = resolveFolderPath(parentId);
+
+    // Skip orphaned items (children of trashed folders)
+    if (parentId && isOrphaned(parentId)) continue;
+
+    const parentPath = resolveFolderPath(parentId) || "";
     const itemPath = parentPath
       ? path.posix.join(parentPath, file.name)
       : file.name;

package/src/core/repository.js

@@ -0,0 +1,309 @@
+/**
+ * Repository — unified data-access layer for Aethel workspaces.
+ *
+ * Wraps all core modules behind a single interface so that both
+ * the CLI and the TUI share the same entry point for state loading,
+ * staging, syncing, file browsing, and history.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { authenticate } from "./auth.js";
+import {
+  AETHEL_DIR,
+  HISTORY_DIR,
+  LATEST_SNAPSHOT,
+  SNAPSHOTS_DIR,
+  readConfig,
+  readLatestSnapshot,
+  writeConfig,
+  writeSnapshot,
+} from "./config.js";
+import { computeDiff } from "./diff.js";
+import {
+  assertNoDuplicateFolders,
+  batchOperateFiles,
+  getAccountInfo,
+  getRemoteState,
+  listAccessibleFiles,
+  syncLocalDirectoryToParent,
+  uploadLocalEntry,
+  withDriveRetry,
+} from "./drive-api.js";
+import {
+  invalidateRemoteCache,
+  readRemoteCache,
+  writeRemoteCache,
+} from "./remote-cache.js";
+import { buildSnapshot, scanLocal } from "./snapshot.js";
+import {
+  stageChange,
+  stageChanges,
+  stageConflictResolution,
+  stagedEntries,
+  unstageAll,
+  unstagePath,
+} from "./staging.js";
+import { executeStaged } from "./sync.js";
+import {
+  deleteLocalEntry,
+  listLocalEntries,
+  renameLocalEntry,
+} from "./local-fs.js";
+
+export class Repository {
+  /**
+   * @param {string|null} root  Workspace root (null for workspace-less commands like auth/clean)
+   * @param {object} [options]
+   * @param {object} [options.drive]       Pre-authenticated drive instance (skips auth)
+   * @param {string} [options.credentials] Path to OAuth credentials JSON
+   * @param {string} [options.token]       Path to OAuth token JSON
+   */
+  constructor(root, options = {}) {
+    this._root = root;
+    this._options = options;
+    this._drive = options.drive || null;
+    this._config = null;
+  }
+
+  get root() {
+    return this._root;
+  }
+
+  get isConnected() {
+    return this._drive !== null;
+  }
+
+  get drive() {
+    if (!this._drive) {
+      throw new Error("Repository is not connected. Call connect() first.");
+    }
+    return this._drive;
+  }
+
+  /** Authenticate and prepare the drive connection. Idempotent. */
+  async connect() {
+    if (this._drive) return;
+    const raw = await authenticate(this._options.credentials, this._options.token);
+    this._drive = withDriveRetry(raw);
+  }
+
+  // ── Config ──────────────────────────────────────────────────────────
+
+  getConfig() {
+    if (!this._config) {
+      this._config = readConfig(this._root);
+    }
+    return this._config;
+  }
+
+  setConfig(data) {
+    writeConfig(this._root, data);
+    this._config = null;
+  }
+
+  // ── State loading (sync workflow) ───────────────────────────────────
+
+  /**
+   * Load full workspace state in parallel, replacing the old
+   * loadWorkspaceState() helper from cli.js.
+   */
+  async loadState({ useCache = true } = {}) {
+    const config = this.getConfig();
+
+    const [local, snapshot] = await Promise.all([
+      scanLocal(this._root),
+      Promise.resolve(readLatestSnapshot(this._root)),
+    ]);
+
+    const remoteState = await this._loadRemoteState({ useCache });
+    const remote = remoteState.files;
+
+    return {
+      config,
+      remote,
+      local,
+      snapshot,
+      diff: computeDiff(snapshot, remote, local, { root: this._root }),
+    };
+  }
+
+  async getRemoteState({ useCache = true } = {}) {
+    return this._loadRemoteState({ useCache });
+  }
+
+  async scanLocal() {
+    return scanLocal(this._root);
+  }
+
+  getSnapshot() {
+    return readLatestSnapshot(this._root);
+  }
+
+  computeDiff(snapshot, remote, local) {
+    return computeDiff(snapshot, remote, local, { root: this._root });
+  }
+
+  // ── Staging ─────────────────────────────────────────────────────────
+
+  getStagedEntries() {
+    return stagedEntries(this._root);
+  }
+
+  stageChange(change) {
+    return stageChange(this._root, change);
+  }
+
+  stageChanges(changes) {
+    return stageChanges(this._root, changes);
+  }
+
+  unstagePath(targetPath) {
+    return unstagePath(this._root, targetPath);
+  }
+
+  unstageAll() {
+    return unstageAll(this._root);
+  }
+
+  stageConflictResolution(change, strategy) {
+    return stageConflictResolution(this._root, change, strategy);
+  }
+
+  // ── Sync execution ──────────────────────────────────────────────────
+
+  async executeStaged(progress) {
+    return executeStaged(this.drive, this._root, progress);
+  }
+
+  /**
+   * Invalidate cache, re-fetch remote + re-scan local, write snapshot.
+   */
+  async saveSnapshot(message = "sync") {
+    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),
+    ]);
+    assertNoDuplicateFolders(remoteState.duplicateFolders);
+    writeRemoteCache(this._root, remoteState, rootFolderId);
+    writeSnapshot(this._root, buildSnapshot(remoteState.files, local, message));
+  }
+
+  // ── Cache management ────────────────────────────────────────────────
+
+  invalidateRemoteCache() {
+    invalidateRemoteCache(this._root);
+  }
+
+  // ── File browser (TUI) ─────────────────────────────────────────────
+
+  async listRemoteFiles({ includeSharedDrives = false } = {}) {
+    return listAccessibleFiles(this.drive, includeSharedDrives);
+  }
+
+  async listLocalEntries(targetPath) {
+    return listLocalEntries(targetPath);
+  }
+
+  async deleteLocalEntry(targetPath) {
+    return deleteLocalEntry(targetPath);
+  }
+
+  async renameLocalEntry(targetPath, newName) {
+    return renameLocalEntry(targetPath, newName);
+  }
+
+  async uploadLocalEntry(localPath, parentId, onProgress) {
+    return uploadLocalEntry(this.drive, localPath, parentId, onProgress);
+  }
+
+  async syncLocalDirectory(localPath, parentId, onProgress) {
+    return syncLocalDirectoryToParent(this.drive, localPath, parentId, onProgress);
+  }
+
+  async batchOperateFiles(files, options) {
+    return batchOperateFiles(this.drive, files, options);
+  }
+
+  async getAccountInfo() {
+    return getAccountInfo(this.drive);
+  }
+
+  // ── History ─────────────────────────────────────────────────────────
+
+  getHistory(limit = 10) {
+    const snapshotsPath = path.join(this._root, AETHEL_DIR, SNAPSHOTS_DIR);
+    const entries = [];
+
+    const latestPath = path.join(snapshotsPath, LATEST_SNAPSHOT);
+    if (fs.existsSync(latestPath)) {
+      entries.push(JSON.parse(fs.readFileSync(latestPath, "utf8")));
+    }
+
+    const historyPath = path.join(snapshotsPath, HISTORY_DIR);
+    if (fs.existsSync(historyPath)) {
+      const historyFiles = fs
+        .readdirSync(historyPath)
+        .filter((f) => f.endsWith(".json"))
+        .sort()
+        .reverse();
+
+      for (const fileName of historyFiles) {
+        entries.push(
+          JSON.parse(fs.readFileSync(path.join(historyPath, fileName), "utf8"))
+        );
+      }
+    }
+
+    return entries.slice(0, limit);
+  }
+
+  getSnapshotByRef(ref) {
+    if (!ref || ref === "HEAD" || ref === "latest") {
+      return readLatestSnapshot(this._root);
+    }
+
+    const historyPath = path.join(
+      this._root,
+      AETHEL_DIR,
+      SNAPSHOTS_DIR,
+      HISTORY_DIR
+    );
+
+    if (!fs.existsSync(historyPath)) return null;
+
+    const files = fs
+      .readdirSync(historyPath)
+      .filter((f) => f.endsWith(".json"))
+      .sort()
+      .reverse();
+
+    const match = files.find((f) => f.startsWith(ref));
+    if (!match) return null;
+
+    return JSON.parse(fs.readFileSync(path.join(historyPath, match), "utf-8"));
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────
+
+  async _loadRemoteState({ useCache = true } = {}) {
+    const config = this.getConfig();
+    const rootFolderId = config.drive_folder_id || null;
+
+    let remoteState = useCache
+      ? readRemoteCache(this._root, rootFolderId)
+      : null;
+
+    if (!remoteState) {
+      remoteState = await getRemoteState(this.drive, rootFolderId);
+      writeRemoteCache(this._root, remoteState, rootFolderId);
+    }
+
+    assertNoDuplicateFolders(remoteState.duplicateFolders);
+    return remoteState;
+  }
+}

package/src/core/snapshot.js

@@ -61,6 +61,9 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       return;
     }
 
+    const subdirs = [];
+    const statPromises = [];
+
     for (const entry of entries) {
       const fullPath = path.join(currentPath, entry.name);
       const relativePath = path
@@ -73,7 +76,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       }
 
       if (entry.isDirectory()) {
-        await walk(fullPath);
+        subdirs.push(fullPath);
         continue;
       }
 
@@ -81,9 +84,17 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
         continue;
       }
 
-      const stat = await fs.promises.stat(fullPath);
-      filesToHash.push({ fullPath, relativePath, stat });
+      statPromises.push(
+        fs.promises.stat(fullPath).then((stat) => {
+          filesToHash.push({ fullPath, relativePath, stat });
+        })
+      );
     }
+
+    await Promise.all([
+      ...statPromises,
+      ...subdirs.map((dir) => walk(dir)),
+    ]);
   }
 
   await walk(resolvedRoot);