pushwork 1.0.0

package/src/index.ts

@@ -0,0 +1,14 @@
+// Core sync functionality
+export * from "./core";
+
+// Utilities
+export * from "./utils";
+
+// Configuration
+export * from "./config";
+
+// Types
+export * from "./types";
+
+// CLI commands (for programmatic use)
+export * from "./cli";

package/src/types/config.ts

@@ -0,0 +1,130 @@
+/**
+ * Global configuration options
+ */
+export interface GlobalConfig {
+  sync_server?: string;
+  sync_server_storage_id?: string;
+  exclude_patterns?: string[];
+  large_file_threshold?: string;
+  diff?: {
+    external_tool?: string;
+    show_binary?: boolean;
+  };
+  sync?: {
+    move_detection_threshold?: number;
+    prompt_threshold?: number;
+    auto_sync?: boolean;
+    parallel_operations?: number;
+  };
+}
+
+/**
+ * Default settings
+ */
+export interface DefaultSettings {
+  remote_repo?: string;
+  exclude_patterns: string[];
+  large_file_threshold: string;
+}
+
+/**
+ * Diff tool settings
+ */
+export interface DiffSettings {
+  external_tool?: string;
+  show_binary: boolean;
+}
+
+/**
+ * Sync behavior settings
+ */
+export interface SyncSettings {
+  move_detection_threshold: number;
+  prompt_threshold: number;
+  auto_sync: boolean;
+  parallel_operations: number;
+}
+
+/**
+ * Per-directory configuration
+ */
+export interface DirectoryConfig {
+  sync_server?: string;
+  sync_server_storage_id?: string;
+  sync_enabled: boolean;
+  root_directory_url?: string; // AutomergeUrl of the root directory document
+  defaults: {
+    exclude_patterns: string[];
+    large_file_threshold: string;
+  };
+  diff: {
+    external_tool?: string;
+    show_binary: boolean;
+  };
+  sync: {
+    move_detection_threshold: number;
+    prompt_threshold: number;
+    auto_sync: boolean;
+    parallel_operations: number;
+  };
+}
+
+/**
+ * CLI command options
+ */
+export interface CommandOptions {
+  dryRun?: boolean;
+  verbose?: boolean;
+  tool?: string;
+  nameOnly?: boolean;
+  oneline?: boolean;
+  remote?: string;
+}
+
+/**
+ * Init command specific options
+ */
+export interface InitOptions extends CommandOptions {
+  // No additional options needed - init creates a new sync directory
+}
+
+/**
+ * Clone command specific options
+ */
+export interface CloneOptions extends CommandOptions {
+  force?: boolean; // Overwrite existing directory
+  syncServer?: string; // Custom sync server URL
+  syncServerStorageId?: string; // Custom sync server storage ID
+}
+
+/**
+ * Sync command specific options
+ */
+export interface SyncOptions extends CommandOptions {
+  dryRun: boolean;
+  force?: boolean;
+}
+
+/**
+ * Diff command specific options
+ */
+export interface DiffOptions extends CommandOptions {
+  tool?: string;
+  nameOnly: boolean;
+}
+
+/**
+ * Log command specific options
+ */
+export interface LogOptions extends CommandOptions {
+  oneline: boolean;
+  since?: string;
+  limit?: number;
+}
+
+/**
+ * Checkout command specific options
+ */
+export interface CheckoutOptions extends CommandOptions {
+  force?: boolean;
+}

package/src/types/documents.ts

@@ -0,0 +1,72 @@
+import { AutomergeUrl } from "@automerge/automerge-repo";
+
+/**
+ * Entry in a directory document
+ */
+export interface DirectoryEntry {
+  name: string;
+  type: "file" | "folder";
+  url: AutomergeUrl;
+}
+
+/**
+ * Directory document structure
+ */
+export interface DirectoryDocument {
+  "@patchwork": { type: "folder" };
+  docs: DirectoryEntry[];
+}
+
+/**
+ * File document structure
+ */
+export interface FileDocument {
+  "@patchwork": { type: "file" };
+  name: string;
+  extension: string;
+  mimeType: string;
+  content: string | Uint8Array;
+  metadata: {
+    permissions: number;
+  };
+}
+
+/**
+ * File type classification
+ */
+export enum FileType {
+  TEXT = "text",
+  BINARY = "binary",
+  DIRECTORY = "directory",
+}
+
+/**
+ * Change type classification for sync operations
+ */
+export enum ChangeType {
+  NO_CHANGE = "no_change",
+  LOCAL_ONLY = "local_only",
+  REMOTE_ONLY = "remote_only",
+  BOTH_CHANGED = "both_changed",
+}
+
+/**
+ * File system entry metadata
+ */
+export interface FileSystemEntry {
+  path: string;
+  type: FileType;
+  size: number;
+  mtime: Date;
+  permissions: number;
+}
+
+/**
+ * Move detection result
+ */
+export interface MoveCandidate {
+  fromPath: string;
+  toPath: string;
+  similarity: number;
+  confidence: "auto" | "prompt" | "low";
+}

package/src/types/index.ts

@@ -0,0 +1,8 @@
+// Document types
+export * from "./documents";
+
+// Snapshot and sync types
+export * from "./snapshot";
+
+// Configuration types
+export * from "./config";

package/src/types/snapshot.ts

@@ -0,0 +1,88 @@
+import { AutomergeUrl, UrlHeads } from "@automerge/automerge-repo";
+
+/**
+ * Tracked file entry in the sync snapshot
+ */
+export interface SnapshotFileEntry {
+  path: string; // Full filesystem path for mapping
+  url: AutomergeUrl; // Automerge document URL
+  head: UrlHeads; // Document head at last sync
+  extension: string; // File extension
+  mimeType: string; // MIME type
+}
+
+/**
+ * Tracked directory entry in the sync snapshot
+ */
+export interface SnapshotDirectoryEntry {
+  path: string; // Full filesystem path for mapping
+  url: AutomergeUrl; // Automerge document URL
+  head: UrlHeads; // Document head at last sync
+  entries: string[]; // List of child entry names
+}
+
+/**
+ * Sync snapshot for local state management
+ */
+export interface SyncSnapshot {
+  timestamp: number;
+  rootPath: string;
+  rootDirectoryUrl?: AutomergeUrl; // URL of the root directory document
+  files: Map<string, SnapshotFileEntry>;
+  directories: Map<string, SnapshotDirectoryEntry>;
+}
+
+/**
+ * Serializable version of sync snapshot for storage
+ */
+export interface SerializableSyncSnapshot {
+  timestamp: number;
+  rootPath: string;
+  rootDirectoryUrl?: AutomergeUrl; // URL of the root directory document
+  files: Array<[string, SnapshotFileEntry]>;
+  directories: Array<[string, SnapshotDirectoryEntry]>;
+}
+
+/**
+ * Sync operation result
+ */
+export interface SyncResult {
+  success: boolean;
+  filesChanged: number;
+  directoriesChanged: number;
+  errors: SyncError[];
+  warnings: string[];
+}
+
+/**
+ * Sync error details
+ */
+export interface SyncError {
+  path: string;
+  operation: string;
+  error: Error;
+  recoverable: boolean;
+}
+
+/**
+ * Sync operation type
+ */
+export enum SyncOperation {
+  CREATE_FILE = "create_file",
+  UPDATE_FILE = "update_file",
+  DELETE_FILE = "delete_file",
+  MOVE_FILE = "move_file",
+  CREATE_DIRECTORY = "create_directory",
+  DELETE_DIRECTORY = "delete_directory",
+  MOVE_DIRECTORY = "move_directory",
+}
+
+/**
+ * Pending sync operation
+ */
+export interface PendingSyncOperation {
+  operation: SyncOperation;
+  path: string;
+  newPath?: string;
+  priority: number;
+}

package/src/utils/content-similarity.ts

@@ -0,0 +1,194 @@
+import { calculateContentHash } from "./fs";
+
+/**
+ * Content similarity calculation for move detection
+ */
+export class ContentSimilarity {
+  private static readonly CHUNK_SIZE = 1024; // 1KB chunks for sampling
+  private static readonly AUTO_THRESHOLD = 0.8;
+  private static readonly PROMPT_THRESHOLD = 0.5;
+
+  /**
+   * Calculate similarity between two content pieces
+   */
+  static async calculateSimilarity(
+    content1: string | Uint8Array,
+    content2: string | Uint8Array
+  ): Promise<number> {
+    // Quick early exit for identical content
+    if (await this.areIdentical(content1, content2)) {
+      return 1.0;
+    }
+
+    // Size-based quick rejection
+    const size1 =
+      typeof content1 === "string" ? content1.length : content1.length;
+    const size2 =
+      typeof content2 === "string" ? content2.length : content2.length;
+    const sizeDiff = Math.abs(size1 - size2) / Math.max(size1, size2);
+
+    if (sizeDiff > 0.5) {
+      return 0.0; // Too different in size
+    }
+
+    // For small files, use full content comparison
+    if (size1 < this.CHUNK_SIZE * 4 && size2 < this.CHUNK_SIZE * 4) {
+      return this.calculateFullSimilarity(content1, content2);
+    }
+
+    // For large files, use sampling
+    return this.calculateSampledSimilarity(content1, content2);
+  }
+
+  /**
+   * Check if two content pieces are identical
+   */
+  private static async areIdentical(
+    content1: string | Uint8Array,
+    content2: string | Uint8Array
+  ): Promise<boolean> {
+    const hash1 = await calculateContentHash(content1);
+    const hash2 = await calculateContentHash(content2);
+    return hash1 === hash2;
+  }
+
+  /**
+   * Calculate similarity for small files using full content
+   */
+  private static calculateFullSimilarity(
+    content1: string | Uint8Array,
+    content2: string | Uint8Array
+  ): number {
+    const str1 =
+      typeof content1 === "string" ? content1 : this.bufferToString(content1);
+    const str2 =
+      typeof content2 === "string" ? content2 : this.bufferToString(content2);
+
+    return this.levenshteinSimilarity(str1, str2);
+  }
+
+  /**
+   * Calculate similarity for large files using sampling
+   */
+  private static calculateSampledSimilarity(
+    content1: string | Uint8Array,
+    content2: string | Uint8Array
+  ): number {
+    const samples1 = this.getSamples(content1);
+    const samples2 = this.getSamples(content2);
+
+    let totalSimilarity = 0;
+    let comparisons = 0;
+
+    for (let i = 0; i < Math.min(samples1.length, samples2.length); i++) {
+      totalSimilarity += this.levenshteinSimilarity(samples1[i], samples2[i]);
+      comparisons++;
+    }
+
+    return comparisons > 0 ? totalSimilarity / comparisons : 0;
+  }
+
+  /**
+   * Get representative samples from content
+   */
+  private static getSamples(content: string | Uint8Array): string[] {
+    const str =
+      typeof content === "string" ? content : this.bufferToString(content);
+    const length = str.length;
+    const samples: string[] = [];
+
+    if (length <= this.CHUNK_SIZE) {
+      samples.push(str);
+      return samples;
+    }
+
+    // Beginning
+    samples.push(str.slice(0, this.CHUNK_SIZE));
+
+    // Middle
+    const midStart = Math.floor(length / 2) - Math.floor(this.CHUNK_SIZE / 2);
+    samples.push(str.slice(midStart, midStart + this.CHUNK_SIZE));
+
+    // End
+    samples.push(str.slice(-this.CHUNK_SIZE));
+
+    return samples;
+  }
+
+  /**
+   * Calculate Levenshtein similarity (0-1 scale)
+   */
+  private static levenshteinSimilarity(str1: string, str2: string): number {
+    if (str1 === str2) return 1.0;
+    if (str1.length === 0 || str2.length === 0) return 0.0;
+
+    const distance = this.levenshteinDistance(str1, str2);
+    const maxLength = Math.max(str1.length, str2.length);
+
+    return 1 - distance / maxLength;
+  }
+
+  /**
+   * Calculate Levenshtein distance
+   */
+  private static levenshteinDistance(str1: string, str2: string): number {
+    const matrix = Array(str2.length + 1)
+      .fill(null)
+      .map(() => Array(str1.length + 1).fill(null));
+
+    for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+    for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+
+    for (let j = 1; j <= str2.length; j++) {
+      for (let i = 1; i <= str1.length; i++) {
+        const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1, // deletion
+          matrix[j - 1][i] + 1, // insertion
+          matrix[j - 1][i - 1] + indicator // substitution
+        );
+      }
+    }
+
+    return matrix[str2.length][str1.length];
+  }
+
+  /**
+   * Convert buffer to string for comparison
+   */
+  private static bufferToString(buffer: Uint8Array): string {
+    // For binary content, use hex representation for comparison
+    return Array.from(buffer)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  /**
+   * Determine confidence level based on similarity score
+   */
+  static getConfidenceLevel(similarity: number): "auto" | "prompt" | "low" {
+    if (similarity >= this.AUTO_THRESHOLD) {
+      return "auto";
+    } else if (similarity >= this.PROMPT_THRESHOLD) {
+      return "prompt";
+    } else {
+      return "low";
+    }
+  }
+
+  /**
+   * Should auto-apply move based on similarity
+   */
+  static shouldAutoApply(similarity: number): boolean {
+    return similarity >= this.AUTO_THRESHOLD;
+  }
+
+  /**
+   * Should prompt user for move confirmation
+   */
+  static shouldPromptUser(similarity: number): boolean {
+    return (
+      similarity >= this.PROMPT_THRESHOLD && similarity < this.AUTO_THRESHOLD
+    );
+  }
+}

package/src/utils/content.ts

@@ -0,0 +1,28 @@
+/**
+ * Compare two content pieces for equality
+ */
+export function isContentEqual(
+  content1: string | Uint8Array | null,
+  content2: string | Uint8Array | null
+): boolean {
+  if (content1 === content2) return true;
+  if (!content1 || !content2) return false;
+
+  if (typeof content1 !== typeof content2) return false;
+
+  if (typeof content1 === "string") {
+    return content1 === content2;
+  } else {
+    // Compare Uint8Array
+    const buf1 = content1 as Uint8Array;
+    const buf2 = content2 as Uint8Array;
+
+    if (buf1.length !== buf2.length) return false;
+
+    for (let i = 0; i < buf1.length; i++) {
+      if (buf1[i] !== buf2[i]) return false;
+    }
+
+    return true;
+  }
+}