aethel 0.1.0

package/src/core/ignore.js

@@ -0,0 +1,146 @@
+/**
+ * .aethelignore support — gitignore-syntax pattern matching.
+ *
+ * Reads a `.aethelignore` file from the workspace root (and optionally
+ * nested directories) and exposes a filter that tests relative paths.
+ * Uses the `ignore` npm package which implements the full gitignore spec.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import ignore from "ignore";
+import { AETHEL_DIR } from "./config.js";
+
+const IGNORE_FILE = ".aethelignore";
+
+// Paths that are always ignored regardless of .aethelignore contents.
+const BUILTIN_PATTERNS = [
+  AETHEL_DIR,
+  `${AETHEL_DIR}/**`,
+  ".git",
+  ".git/**",
+  "node_modules",
+  "node_modules/**",
+  ".DS_Store",
+  "Thumbs.db",
+];
+
+// Module-level cache: avoids re-reading and re-parsing .aethelignore
+// on every call within the same process.
+const _cache = new Map(); // root → { mtime, rules }
+
+/**
+ * Load ignore rules from a workspace root (cached per-process).
+ *
+ * Returns an object with:
+ *   - `ignores(relativePath)` → boolean
+ *   - `filter(paths)` → filtered array of non-ignored paths
+ *   - `patterns` → raw pattern strings for inspection
+ */
+export function loadIgnoreRules(root) {
+  const resolved = path.resolve(root);
+  const ignoreFile = path.join(resolved, IGNORE_FILE);
+
+  // Check if cached version is still valid (same mtime on .aethelignore)
+  let fileMtime = 0;
+  try {
+    fileMtime = fs.statSync(ignoreFile).mtimeMs;
+  } catch {
+    // File doesn't exist — that's fine, we still cache the result
+  }
+
+  const cached = _cache.get(resolved);
+  if (cached && cached.mtime === fileMtime) {
+    return cached.rules;
+  }
+
+  const ig = ignore.default();
+
+  // Always ignore builtins
+  ig.add(BUILTIN_PATTERNS);
+
+  // Load .aethelignore from root
+  const userPatterns = [];
+
+  if (fileMtime > 0) {
+    const content = fs.readFileSync(ignoreFile, "utf-8");
+    const lines = content
+      .split(/\r?\n/)
+      .filter((line) => line.trim() && !line.startsWith("#"));
+    ig.add(lines);
+    userPatterns.push(...lines);
+  }
+
+  const rules = {
+    ignores(relativePath) {
+      const normalized = relativePath.replace(/^\/+/, "");
+      return ig.ignores(normalized);
+    },
+
+    filter(paths) {
+      return ig.filter(paths.map((p) => p.replace(/^\/+/, "")));
+    },
+
+    patterns: [...BUILTIN_PATTERNS, ...userPatterns],
+    userPatterns,
+  };
+
+  _cache.set(resolved, { mtime: fileMtime, rules });
+  return rules;
+}
+
+/** Invalidate the cached rules for a root (call after editing .aethelignore). */
+export function invalidateIgnoreCache(root) {
+  _cache.delete(path.resolve(root));
+}
+
+/**
+ * Create a default .aethelignore file with common patterns.
+ */
+export function createDefaultIgnoreFile(root) {
+  const ignoreFile = path.join(root, IGNORE_FILE);
+
+  if (fs.existsSync(ignoreFile)) {
+    return false;
+  }
+
+  const content = `# Aethel ignore patterns (gitignore syntax)
+# Lines starting with # are comments.
+# See https://git-scm.com/docs/gitignore for pattern syntax.
+
+# OS files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Editor / IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Dependencies
+node_modules/
+.venv/
+__pycache__/
+
+# Build output
+dist/
+build/
+*.pyc
+*.o
+*.so
+
+# Secrets and credentials
+.env
+*.pem
+*.key
+credentials.json
+token.json
+client_secret*.json
+`;
+
+  fs.writeFileSync(ignoreFile, content);
+  return true;
+}

package/src/core/local-fs.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { humanSize } from "./drive-api.js";
+import { loadIgnoreRules } from "./ignore.js";
+import { findRoot } from "./config.js";
+
+export function defaultLocalRoot() {
+  return process.cwd() || os.homedir();
+}
+
+export async function ensureLocalDirectory(targetPath) {
+  const resolvedPath = path.resolve(targetPath);
+  const stat = await fs.promises.stat(resolvedPath);
+
+  if (!stat.isDirectory()) {
+    throw new Error(`Local path is not a directory: ${resolvedPath}`);
+  }
+
+  return resolvedPath;
+}
+
+export async function listLocalEntries(targetPath, { respectIgnore = true } = {}) {
+  const resolvedPath = await ensureLocalDirectory(targetPath);
+
+  // Load ignore rules if inside an Aethel workspace
+  let ignoreRules = null;
+  if (respectIgnore) {
+    const root = findRoot(resolvedPath);
+    if (root) {
+      ignoreRules = loadIgnoreRules(root);
+    }
+  }
+
+  const directoryEntries = await fs.promises.readdir(resolvedPath, {
+    withFileTypes: true,
+  });
+
+  // Resolve root once, outside the filter — not per-entry
+  const workspaceRoot = respectIgnore ? findRoot(resolvedPath) : null;
+
+  const items = await Promise.all(
+    directoryEntries
+      .filter((entry) => {
+        if (entry.name.startsWith(".")) return false;
+        if (ignoreRules && workspaceRoot) {
+          const rel = path.relative(workspaceRoot, path.join(resolvedPath, entry.name)).split(path.sep).join("/");
+          if (ignoreRules.ignores(rel)) return false;
+        }
+        return true;
+      })
+      .map(async (entry) => {
+        const absolutePath = path.join(resolvedPath, entry.name);
+        const stat = await fs.promises.stat(absolutePath);
+
+        return {
+          id: absolutePath,
+          name: entry.name,
+          absolutePath,
+          isDirectory: stat.isDirectory(),
+          size: stat.isDirectory() ? null : stat.size,
+          sizeLabel: stat.isDirectory() ? " DIR  " : humanSize(stat.size),
+          modifiedTime: new Date(stat.mtimeMs).toISOString(),
+        };
+      })
+  );
+
+  return items.sort((left, right) => {
+    if (left.isDirectory !== right.isDirectory) {
+      return left.isDirectory ? -1 : 1;
+    }
+
+    return left.name.localeCompare(right.name);
+  });
+}
+
+export async function deleteLocalEntry(targetPath) {
+  const resolvedPath = path.resolve(targetPath);
+  await fs.promises.rm(resolvedPath, { recursive: true, force: false });
+  return resolvedPath;
+}
+
+export async function renameLocalEntry(targetPath, nextName) {
+  const resolvedPath = path.resolve(targetPath);
+  const trimmedName = nextName.trim();
+
+  if (!trimmedName) {
+    throw new Error("New name cannot be empty.");
+  }
+
+  if (trimmedName.includes(path.sep)) {
+    throw new Error("New name cannot include path separators.");
+  }
+
+  const nextPath = path.join(path.dirname(resolvedPath), trimmedName);
+  if (resolvedPath === nextPath) {
+    return resolvedPath;
+  }
+
+  await fs.promises.access(nextPath).then(
+    () => {
+      throw new Error(`Target already exists: ${nextPath}`);
+    },
+    () => undefined
+  );
+
+  await fs.promises.rename(resolvedPath, nextPath);
+  return nextPath;
+}

package/src/core/remote-cache.js

@@ -0,0 +1,65 @@
+/**
+ * Short-lived cache for remote file listings.
+ *
+ * Stores the last remote file list in .aethel/.remote-cache.json so that
+ * rapid successive commands (e.g. `status` then `add` then `commit`) don't
+ * each make a full Drive API round-trip.
+ *
+ * Default TTL: 60 seconds. Commands that mutate remote state (commit, push)
+ * should invalidate the cache.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { AETHEL_DIR } from "./config.js";
+
+const CACHE_FILE = ".remote-cache.json";
+const DEFAULT_TTL_MS = 60_000; // 60 seconds
+
+function cachePath(root) {
+  return path.join(root, AETHEL_DIR, CACHE_FILE);
+}
+
+export function readRemoteCache(root, rootFolderId = null, ttlMs = DEFAULT_TTL_MS) {
+  const p = cachePath(root);
+  if (!fs.existsSync(p)) return null;
+
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+    const age = Date.now() - (raw.timestamp || 0);
+    if (age > ttlMs) return null;
+    if ((raw.rootFolderId ?? null) !== (rootFolderId ?? null)) {
+      return null;
+    }
+    if (!Array.isArray(raw.files) || !Array.isArray(raw.duplicateFolders)) {
+      return null;
+    }
+    return {
+      files: raw.files,
+      duplicateFolders: raw.duplicateFolders,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function writeRemoteCache(root, remoteState, rootFolderId = null) {
+  const p = cachePath(root);
+  fs.writeFileSync(
+    p,
+    JSON.stringify({
+      timestamp: Date.now(),
+      rootFolderId: rootFolderId ?? null,
+      count: remoteState.files.length,
+      files: remoteState.files,
+      duplicateFolders: remoteState.duplicateFolders,
+    }) + "\n"
+  );
+}
+
+export function invalidateRemoteCache(root) {
+  const p = cachePath(root);
+  if (fs.existsSync(p)) {
+    fs.unlinkSync(p);
+  }
+}

package/src/core/snapshot.js

@@ -0,0 +1,159 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { AETHEL_DIR } from "./config.js";
+import { loadIgnoreRules } from "./ignore.js";
+
+const HASH_CACHE_FILE = ".hash-cache.json";
+
+export async function md5Local(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("md5");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+// ── Hash cache ───────────────────────────────────────────────────────
+
+function hashCachePath(root) {
+  return path.join(root, AETHEL_DIR, HASH_CACHE_FILE);
+}
+
+function loadHashCache(root) {
+  const p = hashCachePath(root);
+  if (!fs.existsSync(p)) return new Map();
+  try {
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    return new Map(Object.entries(data));
+  } catch {
+    return new Map();
+  }
+}
+
+function saveHashCache(root, cache) {
+  const p = hashCachePath(root);
+  const obj = Object.fromEntries(cache);
+  fs.writeFileSync(p, JSON.stringify(obj) + "\n");
+}
+
+// ── Scanning ─────────────────────────────────────────────────────────
+
+const PARALLEL_HASH_LIMIT = 32;
+
+export async function scanLocal(root, { respectIgnore = true } = {}) {
+  const resolvedRoot = path.resolve(root);
+  const ignoreRules = respectIgnore ? loadIgnoreRules(resolvedRoot) : null;
+  const hashCache = loadHashCache(resolvedRoot);
+  const nextCache = new Map();
+
+  // Phase 1: collect all file stats (fast — no hashing yet)
+  const filesToHash = [];
+
+  async function walk(currentPath) {
+    let entries;
+    try {
+      entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      const relativePath = path
+        .relative(resolvedRoot, fullPath)
+        .split(path.sep)
+        .join("/");
+
+      if (ignoreRules?.ignores(relativePath)) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const stat = await fs.promises.stat(fullPath);
+      filesToHash.push({ fullPath, relativePath, stat });
+    }
+  }
+
+  await walk(resolvedRoot);
+
+  // Phase 2: hash files in parallel batches, using cache when possible
+  const result = {};
+
+  for (let i = 0; i < filesToHash.length; i += PARALLEL_HASH_LIMIT) {
+    const batch = filesToHash.slice(i, i + PARALLEL_HASH_LIMIT);
+    const hashes = await Promise.all(
+      batch.map(async ({ fullPath, relativePath, stat }) => {
+        const md5 = await getMd5Cached(hashCache, nextCache, fullPath, relativePath, stat);
+        return { relativePath, stat, md5 };
+      })
+    );
+
+    for (const { relativePath, stat, md5 } of hashes) {
+      result[relativePath] = {
+        localPath: relativePath,
+        size: stat.size,
+        md5,
+        modifiedTime: new Date(stat.mtimeMs).toISOString(),
+      };
+    }
+  }
+
+  // Persist updated cache
+  saveHashCache(resolvedRoot, nextCache);
+  return result;
+}
+
+async function getMd5Cached(oldCache, newCache, fullPath, relativePath, stat) {
+  const key = `${stat.mtimeMs}:${stat.size}`;
+  const cached = oldCache.get(relativePath);
+
+  let md5;
+  if (cached && cached.startsWith(key + ":")) {
+    // Cache hit: mtime and size match
+    md5 = cached.slice(key.length + 1);
+  } else {
+    // Cache miss: compute hash
+    md5 = await md5Local(fullPath);
+  }
+
+  newCache.set(relativePath, `${key}:${md5}`);
+  return md5;
+}
+
+// ── Snapshot building ────────────────────────────────────────────────
+
+export function buildSnapshot(remoteFiles, localFiles, message = "") {
+  const files = {};
+
+  for (const file of remoteFiles) {
+    files[file.id] = {
+      id: file.id,
+      name: file.name,
+      path: file.path,
+      md5Checksum: file.md5Checksum ?? null,
+      size: file.size ?? null,
+      mimeType: file.mimeType || "",
+      modifiedTime: file.modifiedTime ?? null,
+      localPath: file.path,
+    };
+  }
+
+  return {
+    timestamp: new Date().toISOString(),
+    message,
+    files,
+    localFiles: { ...localFiles },
+  };
+}

package/src/core/staging.js

@@ -0,0 +1,125 @@
+import { readIndex, writeIndex } from "./config.js";
+
+export function stagedEntries(root) {
+  return readIndex(root).staged || [];
+}
+
+function changeToEntry(change) {
+  const entry = {
+    action: change.suggestedAction,
+    path: change.path,
+    localPath: change.localMeta?.localPath || change.path,
+  };
+
+  if (change.fileId) {
+    entry.fileId = change.fileId;
+  }
+
+  if (change.remoteMeta?.path) {
+    entry.remotePath = change.remoteMeta.path;
+  }
+
+  return entry;
+}
+
+export function stageChange(root, change) {
+  const index = readIndex(root);
+  const staged = (index.staged || []).filter(
+    (entry) => entry.path !== change.path
+  );
+  staged.push(changeToEntry(change));
+  index.staged = staged;
+  writeIndex(root, index);
+}
+
+export function stageChanges(root, changes) {
+  const index = readIndex(root);
+  const byPath = new Map((index.staged || []).map((entry) => [entry.path, entry]));
+
+  for (const change of changes) {
+    byPath.set(change.path, changeToEntry(change));
+  }
+
+  index.staged = [...byPath.values()];
+  writeIndex(root, index);
+  return changes.length;
+}
+
+export function unstagePath(root, targetPath) {
+  const index = readIndex(root);
+  const staged = index.staged || [];
+  const next = staged.filter((entry) => entry.path !== targetPath);
+
+  if (next.length === staged.length) {
+    return false;
+  }
+
+  index.staged = next;
+  writeIndex(root, index);
+  return true;
+}
+
+export function unstageAll(root) {
+  const index = readIndex(root);
+  const count = (index.staged || []).length;
+  index.staged = [];
+  writeIndex(root, index);
+  return count;
+}
+
+/**
+ * Stage a conflict with an explicit resolution strategy.
+ * @param {"ours"|"theirs"|"both"} strategy
+ */
+export function stageConflictResolution(root, change, strategy) {
+  if (strategy === "theirs") {
+    // Keep remote version → download
+    return stageChange(root, {
+      ...change,
+      changeType: "remote_modified",
+      suggestedAction: "download",
+    });
+  }
+
+  if (strategy === "ours") {
+    // Keep local version → upload
+    return stageChange(root, {
+      ...change,
+      changeType: "local_modified",
+      suggestedAction: "upload",
+    });
+  }
+
+  if (strategy === "both") {
+    // Keep both: download remote as .remote copy, keep local as-is, then upload local
+    const index = readIndex(root);
+    const staged = (index.staged || []).filter(
+      (entry) => entry.path !== change.path
+    );
+
+    // Stage download of remote with a renamed path
+    const ext = change.path.includes(".") ? "." + change.path.split(".").pop() : "";
+    const base = ext ? change.path.slice(0, -ext.length) : change.path;
+    const remoteCopyPath = `${base}.remote${ext}`;
+
+    staged.push({
+      action: "download",
+      path: remoteCopyPath,
+      localPath: remoteCopyPath,
+      fileId: change.fileId,
+      remotePath: change.remoteMeta?.path || change.path,
+    });
+
+    // Stage upload of local version
+    staged.push({
+      action: "upload",
+      path: change.path,
+      localPath: change.localMeta?.localPath || change.path,
+      fileId: change.fileId,
+      remotePath: change.remoteMeta?.path || change.path,
+    });
+
+    index.staged = staged;
+    writeIndex(root, index);
+  }
+}