pushwork 1.0.0

package/src/core/move-detection.ts

@@ -0,0 +1,269 @@
+import {
+  SyncSnapshot,
+  MoveCandidate,
+  FileType,
+  SnapshotFileEntry,
+} from "../types";
+import { ContentSimilarity, readFileContent, getRelativePath } from "../utils";
+import { DetectedChange, ChangeType } from "./change-detection";
+
+/**
+ * Move detection engine
+ */
+export class MoveDetector {
+  private static readonly AUTO_THRESHOLD = 0.8;
+  private static readonly PROMPT_THRESHOLD = 0.5;
+
+  /**
+   * Detect file moves by analyzing deleted and created files
+   */
+  async detectMoves(
+    changes: DetectedChange[],
+    snapshot: SyncSnapshot,
+    rootPath: string
+  ): Promise<{ moves: MoveCandidate[]; remainingChanges: DetectedChange[] }> {
+    // Separate deletions and creations
+    const deletedFiles = changes.filter(
+      (c) => !c.localContent && c.changeType === ChangeType.LOCAL_ONLY
+    );
+    const createdFiles = changes.filter(
+      (c) =>
+        c.localContent &&
+        c.changeType === ChangeType.LOCAL_ONLY &&
+        !snapshot.files.has(c.path)
+    );
+
+    if (deletedFiles.length === 0 || createdFiles.length === 0) {
+      return { moves: [], remainingChanges: changes };
+    }
+
+    const moves: MoveCandidate[] = [];
+    const usedCreations = new Set<string>();
+    const usedDeletions = new Set<string>();
+
+    // Find potential moves by comparing content
+    for (const deletedFile of deletedFiles) {
+      const deletedContent = await this.getDeletedFileContent(
+        deletedFile,
+        snapshot
+      );
+      if (!deletedContent) continue;
+
+      let bestMatch: { file: DetectedChange; similarity: number } | null = null;
+
+      for (const createdFile of createdFiles) {
+        if (usedCreations.has(createdFile.path)) continue;
+        if (!createdFile.localContent) continue;
+
+        const similarity = await ContentSimilarity.calculateSimilarity(
+          deletedContent,
+          createdFile.localContent
+        );
+
+        if (similarity >= MoveDetector.PROMPT_THRESHOLD) {
+          if (!bestMatch || similarity > bestMatch.similarity) {
+            bestMatch = { file: createdFile, similarity };
+          }
+        }
+      }
+
+      if (bestMatch) {
+        const confidence = ContentSimilarity.getConfidenceLevel(
+          bestMatch.similarity
+        );
+
+        // Always report the potential move (for logging/prompting)
+        moves.push({
+          fromPath: deletedFile.path,
+          toPath: bestMatch.file.path,
+          similarity: bestMatch.similarity,
+          confidence,
+        });
+
+        // Only consume the deletion/creation pair when we would auto-apply the move.
+        // If we only want to prompt, leave the original changes in place so
+        // sync can still proceed as delete+create (avoids infinite warning loop).
+        if (bestMatch.similarity >= MoveDetector.AUTO_THRESHOLD) {
+          usedCreations.add(bestMatch.file.path);
+          usedDeletions.add(deletedFile.path);
+        }
+      }
+    }
+
+    // Filter out changes that are part of moves
+    const remainingChanges = changes.filter(
+      (change) =>
+        !usedCreations.has(change.path) && !usedDeletions.has(change.path)
+    );
+
+    return { moves, remainingChanges };
+  }
+
+  /**
+   * Get content of a deleted file from snapshot
+   */
+  private async getDeletedFileContent(
+    deletedFile: DetectedChange,
+    snapshot: SyncSnapshot
+  ): Promise<string | Uint8Array | null> {
+    const snapshotEntry = snapshot.files.get(deletedFile.path);
+    if (!snapshotEntry) return null;
+
+    // Return remote content if available, otherwise null
+    return deletedFile.remoteContent || null;
+  }
+
+  /**
+   * Group moves by confidence level
+   */
+  groupMovesByConfidence(moves: MoveCandidate[]): {
+    autoMoves: MoveCandidate[];
+    promptMoves: MoveCandidate[];
+    lowConfidenceMoves: MoveCandidate[];
+  } {
+    const autoMoves = moves.filter((m) => m.confidence === "auto");
+    const promptMoves = moves.filter((m) => m.confidence === "prompt");
+    const lowConfidenceMoves = moves.filter((m) => m.confidence === "low");
+
+    return { autoMoves, promptMoves, lowConfidenceMoves };
+  }
+
+  /**
+   * Validate move candidates to avoid conflicts
+   */
+  validateMoves(moves: MoveCandidate[]): {
+    validMoves: MoveCandidate[];
+    conflicts: Array<{ moves: MoveCandidate[]; reason: string }>;
+  } {
+    const validMoves: MoveCandidate[] = [];
+    const conflicts: Array<{ moves: MoveCandidate[]; reason: string }> = [];
+
+    // Check for multiple sources mapping to same destination
+    const destinationMap = new Map<string, MoveCandidate[]>();
+    for (const move of moves) {
+      if (!destinationMap.has(move.toPath)) {
+        destinationMap.set(move.toPath, []);
+      }
+      destinationMap.get(move.toPath)!.push(move);
+    }
+
+    // Check for multiple destinations from same source
+    const sourceMap = new Map<string, MoveCandidate[]>();
+    for (const move of moves) {
+      if (!sourceMap.has(move.fromPath)) {
+        sourceMap.set(move.fromPath, []);
+      }
+      sourceMap.get(move.fromPath)!.push(move);
+    }
+
+    for (const move of moves) {
+      const destinationConflicts = destinationMap.get(move.toPath)!;
+      const sourceConflicts = sourceMap.get(move.fromPath)!;
+
+      if (destinationConflicts.length > 1) {
+        conflicts.push({
+          moves: destinationConflicts,
+          reason: `Multiple files moving to ${move.toPath}`,
+        });
+      } else if (sourceConflicts.length > 1) {
+        conflicts.push({
+          moves: sourceConflicts,
+          reason: `File ${move.fromPath} has multiple potential destinations`,
+        });
+      } else {
+        validMoves.push(move);
+      }
+    }
+
+    return { validMoves, conflicts };
+  }
+
+  /**
+   * Apply move detection heuristics
+   */
+  applyHeuristics(moves: MoveCandidate[]): MoveCandidate[] {
+    return moves
+      .filter((move) => {
+        // Filter out moves within the same directory unless similarity is very high
+        const fromDir = this.getDirectoryPath(move.fromPath);
+        const toDir = this.getDirectoryPath(move.toPath);
+
+        if (fromDir === toDir && move.similarity < 0.9) {
+          return false;
+        }
+
+        // Filter out moves with very different file extensions unless similarity is perfect
+        const fromExt = this.getFileExtension(move.fromPath);
+        const toExt = this.getFileExtension(move.toPath);
+
+        if (fromExt !== toExt && move.similarity < 1.0) {
+          return false;
+        }
+
+        return true;
+      })
+      .sort((a, b) => b.similarity - a.similarity); // Sort by similarity descending
+  }
+
+  /**
+   * Get directory path from file path
+   */
+  private getDirectoryPath(filePath: string): string {
+    const lastSlash = filePath.lastIndexOf("/");
+    return lastSlash >= 0 ? filePath.substring(0, lastSlash) : "";
+  }
+
+  /**
+   * Get file extension from file path
+   */
+  private getFileExtension(filePath: string): string {
+    const lastDot = filePath.lastIndexOf(".");
+    const lastSlash = filePath.lastIndexOf("/");
+
+    if (lastDot > lastSlash && lastDot >= 0) {
+      return filePath.substring(lastDot + 1).toLowerCase();
+    }
+
+    return "";
+  }
+
+  /**
+   * Check if a move should be auto-applied
+   */
+  shouldAutoApply(move: MoveCandidate): boolean {
+    return move.confidence === "auto";
+  }
+
+  /**
+   * Check if a move should prompt the user
+   */
+  shouldPromptUser(move: MoveCandidate): boolean {
+    return move.confidence === "prompt";
+  }
+
+  /**
+   * Format move for display
+   */
+  formatMove(move: MoveCandidate): string {
+    const percentage = Math.round(move.similarity * 100);
+    return `${move.fromPath} → ${move.toPath} (${percentage}% similar)`;
+  }
+
+  /**
+   * Calculate move statistics
+   */
+  calculateStats(moves: MoveCandidate[]): {
+    total: number;
+    auto: number;
+    prompt: number;
+    averageSimilarity: number;
+  } {
+    const total = moves.length;
+    const auto = moves.filter((m) => m.confidence === "auto").length;
+    const prompt = moves.filter((m) => m.confidence === "prompt").length;
+    const averageSimilarity =
+      total > 0 ? moves.reduce((sum, m) => sum + m.similarity, 0) / total : 0;
+
+    return { total, auto, prompt, averageSimilarity };
+  }
+}

package/src/core/snapshot.ts

@@ -0,0 +1,285 @@
+/**
+ * pvh TODO: the files & directories could be unified into a single map of entries with a type field
+ */
+
+import * as fs from "fs/promises";
+import * as path from "path";
+import {
+  SyncSnapshot,
+  SerializableSyncSnapshot,
+  SnapshotFileEntry,
+  SnapshotDirectoryEntry,
+} from "../types";
+import { pathExists, ensureDirectoryExists } from "../utils";
+
+/**
+ * Manages sync snapshots for local state tracking
+ */
+export class SnapshotManager {
+  private static readonly SNAPSHOT_FILENAME = "snapshot.json";
+  private static readonly SYNC_TOOL_DIR = ".pushwork";
+
+  constructor(private rootPath: string) {}
+
+  /**
+   * Get path to sync tool directory
+   */
+  private getSyncToolDir(): string {
+    return path.join(this.rootPath, SnapshotManager.SYNC_TOOL_DIR);
+  }
+
+  /**
+   * Get path to snapshot file
+   */
+  private getSnapshotPath(): string {
+    return path.join(this.getSyncToolDir(), SnapshotManager.SNAPSHOT_FILENAME);
+  }
+
+  /**
+   * Check if snapshot exists
+   */
+  async exists(): Promise<boolean> {
+    return await pathExists(this.getSnapshotPath());
+  }
+
+  /**
+   * Load snapshot from disk
+   */
+  async load(): Promise<SyncSnapshot | null> {
+    try {
+      const snapshotPath = this.getSnapshotPath();
+      if (!(await pathExists(snapshotPath))) {
+        return null;
+      }
+
+      const content = await fs.readFile(snapshotPath, "utf8");
+      const serializable: SerializableSyncSnapshot = JSON.parse(content);
+
+      return this.deserializeSnapshot(serializable);
+    } catch (error) {
+      console.warn(`Failed to load snapshot: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Save snapshot to disk
+   */
+  async save(snapshot: SyncSnapshot): Promise<void> {
+    try {
+      await ensureDirectoryExists(this.getSyncToolDir());
+
+      const serializable = this.serializeSnapshot(snapshot);
+      const content = JSON.stringify(serializable, null, 2);
+
+      await fs.writeFile(this.getSnapshotPath(), content, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to save snapshot: ${error}`);
+    }
+  }
+
+  /**
+   * Create empty snapshot
+   */
+  createEmpty(): SyncSnapshot {
+    return {
+      timestamp: Date.now(),
+      rootPath: this.rootPath,
+      rootDirectoryUrl: undefined,
+      files: new Map(),
+      directories: new Map(),
+    };
+  }
+
+  /**
+   * Update file entry in snapshot
+   */
+  updateFileEntry(
+    snapshot: SyncSnapshot,
+    relativePath: string,
+    entry: SnapshotFileEntry
+  ): void {
+    snapshot.files.set(relativePath, entry);
+    snapshot.timestamp = Date.now();
+  }
+
+  /**
+   * Update directory entry in snapshot
+   */
+  updateDirectoryEntry(
+    snapshot: SyncSnapshot,
+    relativePath: string,
+    entry: SnapshotDirectoryEntry
+  ): void {
+    snapshot.directories.set(relativePath, entry);
+    snapshot.timestamp = Date.now();
+  }
+
+  /**
+   * Remove file entry from snapshot
+   */
+  removeFileEntry(snapshot: SyncSnapshot, relativePath: string): void {
+    snapshot.files.delete(relativePath);
+    snapshot.timestamp = Date.now();
+  }
+
+  /**
+   * Remove directory entry from snapshot
+   */
+  removeDirectoryEntry(snapshot: SyncSnapshot, relativePath: string): void {
+    snapshot.directories.delete(relativePath);
+    snapshot.timestamp = Date.now();
+  }
+
+  /**
+   * Get all file paths in snapshot
+   */
+  getFilePaths(snapshot: SyncSnapshot): string[] {
+    return Array.from(snapshot.files.keys());
+  }
+
+  /**
+   * Get all directory paths in snapshot
+   */
+  getDirectoryPaths(snapshot: SyncSnapshot): string[] {
+    return Array.from(snapshot.directories.keys());
+  }
+
+  /**
+   * Get file entry by path
+   */
+  getFileEntry(
+    snapshot: SyncSnapshot,
+    relativePath: string
+  ): SnapshotFileEntry | undefined {
+    return snapshot.files.get(relativePath);
+  }
+
+  /**
+   * Get directory entry by path
+   */
+  getDirectoryEntry(
+    snapshot: SyncSnapshot,
+    relativePath: string
+  ): SnapshotDirectoryEntry | undefined {
+    return snapshot.directories.get(relativePath);
+  }
+
+  /**
+   * Check if path is tracked in snapshot
+   */
+  isTracked(snapshot: SyncSnapshot, relativePath: string): boolean {
+    return (
+      snapshot.files.has(relativePath) || snapshot.directories.has(relativePath)
+    );
+  }
+
+  /**
+   * Get snapshot statistics
+   */
+  getStats(snapshot: SyncSnapshot): {
+    files: number;
+    directories: number;
+    timestamp: Date;
+  } {
+    return {
+      files: snapshot.files.size,
+      directories: snapshot.directories.size,
+      timestamp: new Date(snapshot.timestamp),
+    };
+  }
+
+  /**
+   * Backup current snapshot
+   */
+  async backup(): Promise<void> {
+    const snapshotPath = this.getSnapshotPath();
+    if (await pathExists(snapshotPath)) {
+      const backupPath = `${snapshotPath}.backup.${Date.now()}`;
+      await fs.copyFile(snapshotPath, backupPath);
+    }
+  }
+
+  /**
+   * Validate snapshot integrity
+   */
+  validate(snapshot: SyncSnapshot): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!snapshot.timestamp || snapshot.timestamp <= 0) {
+      errors.push("Invalid timestamp");
+    }
+
+    if (!snapshot.rootPath) {
+      errors.push("Missing root path");
+    }
+
+    if (!snapshot.files || !snapshot.directories) {
+      errors.push("Missing files or directories map");
+    }
+
+    // Check for path conflicts (file and directory with same path)
+    for (const filePath of snapshot.files.keys()) {
+      if (snapshot.directories.has(filePath)) {
+        errors.push(
+          `Path conflict: ${filePath} exists as both file and directory`
+        );
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Convert snapshot to serializable format
+   */
+  private serializeSnapshot(snapshot: SyncSnapshot): SerializableSyncSnapshot {
+    return {
+      timestamp: snapshot.timestamp,
+      rootPath: snapshot.rootPath,
+      rootDirectoryUrl: snapshot.rootDirectoryUrl,
+      files: Array.from(snapshot.files.entries()),
+      directories: Array.from(snapshot.directories.entries()),
+    };
+  }
+
+  /**
+   * Convert serializable format back to snapshot
+   */
+  private deserializeSnapshot(
+    serializable: SerializableSyncSnapshot
+  ): SyncSnapshot {
+    return {
+      timestamp: serializable.timestamp,
+      rootPath: serializable.rootPath,
+      rootDirectoryUrl: serializable.rootDirectoryUrl,
+      files: new Map(serializable.files),
+      directories: new Map(serializable.directories),
+    };
+  }
+
+  /**
+   * Clear all snapshot data
+   */
+  clear(snapshot: SyncSnapshot): void {
+    snapshot.files.clear();
+    snapshot.directories.clear();
+    snapshot.timestamp = Date.now();
+  }
+
+  /**
+   * Clone snapshot for safe manipulation
+   */
+  clone(snapshot: SyncSnapshot): SyncSnapshot {
+    return {
+      timestamp: snapshot.timestamp,
+      rootPath: snapshot.rootPath,
+      rootDirectoryUrl: snapshot.rootDirectoryUrl,
+      files: new Map(snapshot.files),
+      directories: new Map(snapshot.directories),
+    };
+  }
+}