pushwork 2.0.0-a.sub.0 → 2.0.0-preview

package/src/core/config.ts

@@ -1,313 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-import {
-  GlobalConfig,
-  DirectoryConfig,
-  DEFAULT_SYNC_SERVER,
-} from "../types/index.js";
-import { pathExists, ensureDirectoryExists } from "../utils/index.js";
-
-/**
- * Configuration manager for pushwork
- */
-export class ConfigManager {
-  private static readonly GLOBAL_CONFIG_DIR = ".pushwork";
-  private static readonly CONFIG_FILENAME = "config.json";
-
-  static readonly CONFIG_DIR = ".pushwork";
-
-  constructor(private workingDir?: string) {}
-
-  /**
-   * Get global configuration path
-   */
-  private getGlobalConfigPath(): string {
-    return path.join(
-      os.homedir(),
-      ConfigManager.GLOBAL_CONFIG_DIR,
-      ConfigManager.CONFIG_FILENAME
-    );
-  }
-
-  /**
-   * Get local configuration path
-   */
-  private getLocalConfigPath(): string {
-    if (!this.workingDir) {
-      throw new Error("Working directory not set for local config");
-    }
-    return path.join(
-      this.workingDir,
-      ConfigManager.CONFIG_DIR,
-      ConfigManager.CONFIG_FILENAME
-    );
-  }
-
-  /**
-   * Load global configuration
-   */
-  async loadGlobal(): Promise<GlobalConfig | null> {
-    try {
-      const configPath = this.getGlobalConfigPath();
-      if (!(await pathExists(configPath))) {
-        return null;
-      }
-
-      const content = await fs.readFile(configPath, "utf8");
-      return JSON.parse(content) as GlobalConfig;
-    } catch (error) {
-      // Failed to load global config
-      return null;
-    }
-  }
-
-  /**
-   * Save global configuration
-   */
-  async saveGlobal(config: GlobalConfig): Promise<void> {
-    try {
-      const configPath = this.getGlobalConfigPath();
-      await ensureDirectoryExists(path.dirname(configPath));
-
-      const content = JSON.stringify(config, null, 2);
-      await fs.writeFile(configPath, content, "utf8");
-    } catch (error) {
-      throw new Error(`Failed to save global config: ${error}`);
-    }
-  }
-
-  /**
-   * Load local/directory configuration
-   */
-  async load(): Promise<DirectoryConfig | null> {
-    if (!this.workingDir) {
-      return null;
-    }
-
-    try {
-      const configPath = this.getLocalConfigPath();
-      if (!(await pathExists(configPath))) {
-        return null;
-      }
-
-      const content = await fs.readFile(configPath, "utf8");
-      return JSON.parse(content) as DirectoryConfig;
-    } catch (error) {
-      // Failed to load local config
-      return null;
-    }
-  }
-
-  /**
-   * Save local/directory configuration
-   */
-  async save(config: DirectoryConfig): Promise<void> {
-    if (!this.workingDir) {
-      throw new Error("Working directory not set for local config");
-    }
-
-    try {
-      const configPath = this.getLocalConfigPath();
-      await ensureDirectoryExists(path.dirname(configPath));
-
-      const content = JSON.stringify(config, null, 2);
-      await fs.writeFile(configPath, content, "utf8");
-    } catch (error) {
-      throw new Error(`Failed to save local config: ${error}`);
-    }
-  }
-
-  private getDefaultGlobalConfig(): GlobalConfig {
-    return {
-      exclude_patterns: [
-        ".git",
-        "node_modules",
-        "*.tmp",
-        ".DS_Store",
-        ".pushwork",
-      ],
-      artifact_directories: ["dist"],
-      sync_server: DEFAULT_SYNC_SERVER,
-      sync: {
-        move_detection_threshold: 0.7,
-      },
-    };
-  }
-
-  /**
-   * Get default configuration
-   */
-  getDefaultDirectoryConfig(): DirectoryConfig {
-    return {
-      sync_enabled: true,
-      sync_server: DEFAULT_SYNC_SERVER,
-      exclude_patterns: [
-        ".git",
-        "node_modules",
-        "*.tmp",
-        ".pushwork",
-        ".DS_Store",
-      ],
-      artifact_directories: ["dist"],
-      sync: {
-        move_detection_threshold: 0.7,
-      },
-    };
-  }
-
-  /**
-   * Get merged configuration (global + local)
-   */
-  async getMerged(): Promise<DirectoryConfig> {
-    const globalConfig = await this.loadGlobal();
-    const localConfig = await this.load();
-
-    // Merge configurations: default < global < local
-    let merged = this.getDefaultDirectoryConfig();
-
-    if (globalConfig) {
-      merged = this.mergeConfigs(merged, globalConfig);
-    }
-
-    if (localConfig) {
-      merged = this.mergeConfigs(merged, localConfig);
-    }
-
-    return merged;
-  }
-
-  /**
-   * Initialize with CLI option overrides
-   * Creates a new config with defaults + CLI overrides and saves it
-   */
-  async initializeWithOverrides(
-    overrides: Partial<DirectoryConfig> = {}
-  ): Promise<DirectoryConfig> {
-    const config = this.mergeConfigs(this.getDefaultDirectoryConfig(), overrides);
-    await this.save(config);
-    return config;
-  }
-
-  /**
-   * Merge two configuration objects
-   */
-  private mergeConfigs(
-    base: DirectoryConfig,
-    override: Partial<DirectoryConfig> | GlobalConfig
-  ): DirectoryConfig {
-    const merged = { ...base };
-
-    if ("sync_server" in override && override.sync_server !== undefined) {
-      merged.sync_server = override.sync_server;
-    }
-
-    if ("sync_enabled" in override && override.sync_enabled !== undefined) {
-      merged.sync_enabled = override.sync_enabled;
-    }
-
-    // Handle GlobalConfig structure
-    if ("exclude_patterns" in override && override.exclude_patterns) {
-      merged.exclude_patterns = override.exclude_patterns;
-    }
-
-    if ("artifact_directories" in override && override.artifact_directories) {
-      merged.artifact_directories = override.artifact_directories;
-    }
-
-    if ("sync" in override && override.sync) {
-      merged.sync = { ...merged.sync, ...override.sync };
-    }
-
-    return merged;
-  }
-
-  /**
-   * Create default global configuration
-   */
-  async createDefaultGlobal(): Promise<void> {
-    const defaultGlobal = this.getDefaultGlobalConfig();
-    await this.saveGlobal(defaultGlobal);
-  }
-
-  /**
-   * Check if global configuration exists
-   */
-  async globalConfigExists(): Promise<boolean> {
-    return await pathExists(this.getGlobalConfigPath());
-  }
-
-  /**
-   * Check if local configuration exists
-   */
-  async localConfigExists(): Promise<boolean> {
-    if (!this.workingDir) return false;
-    return await pathExists(this.getLocalConfigPath());
-  }
-
-  /**
-   * Get configuration value by path (e.g., 'sync.move_detection_threshold')
-   */
-  async getValue(keyPath: string): Promise<any> {
-    const config = await this.getMerged();
-
-    const keys = keyPath.split(".");
-    let value: any = config;
-
-    for (const key of keys) {
-      if (value && typeof value === "object" && key in value) {
-        value = value[key];
-      } else {
-        return undefined;
-      }
-    }
-
-    return value;
-  }
-
-  /**
-   * Set configuration value by path
-   */
-  async setValue(keyPath: string, value: any): Promise<void> {
-    const config = (await this.load()) || ({} as DirectoryConfig);
-
-    const keys = keyPath.split(".");
-    let current: any = config;
-
-    // Navigate to the parent of the target key
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i];
-      if (!(key in current) || typeof current[key] !== "object") {
-        current[key] = {};
-      }
-      current = current[key];
-    }
-
-    // Set the value
-    const finalKey = keys[keys.length - 1];
-    current[finalKey] = value;
-
-    await this.save(config);
-  }
-
-  /**
-   * Validate configuration
-   */
-  validate(config: DirectoryConfig): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    if (config.sync?.move_detection_threshold !== undefined) {
-      if (
-        config.sync.move_detection_threshold < 0 ||
-        config.sync.move_detection_threshold > 1
-      ) {
-        errors.push("move_detection_threshold must be between 0 and 1");
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-    };
-  }
-}

package/src/core/index.ts

@@ -1,5 +0,0 @@
-export * from "./snapshot.js";
-export * from "./change-detection.js";
-export * from "./move-detection.js";
-export * from "./sync-engine.js";
-export * from "./config.js";

package/src/core/move-detection.ts

@@ -1,169 +0,0 @@
-import { SyncSnapshot, MoveCandidate } from "../types/index.js";
-import { isTextFile } from "../utils/index.js";
-import { stringSimilarity } from "../utils/string-similarity.js";
-import { ChangeType, DetectedChange } from "../types/index.js";
-
-/**
- * Simplified move detection engine
- */
-export class MoveDetector {
-  private readonly moveThreshold: number;
-
-  constructor(moveThreshold: number = 0.7) {
-    this.moveThreshold = moveThreshold;
-  }
-
-  /**
-   * Detect file moves by analyzing deleted and created files
-   */
-  async detectMoves(
-    changes: DetectedChange[],
-    snapshot: SyncSnapshot
-  ): Promise<{ moves: MoveCandidate[]; remainingChanges: DetectedChange[] }> {
-    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 = deletedFile.remoteContent;
-      if (deletedContent === null) continue;
-
-      let bestMatch: { file: DetectedChange; similarity: number } | null = null;
-
-      for (const createdFile of createdFiles) {
-        if (usedCreations.has(createdFile.path)) continue;
-        if (createdFile.localContent === null) continue;
-
-        const similarity = await this.calculateSimilarity(
-          deletedContent,
-          createdFile.localContent,
-          deletedFile.path
-        );
-
-        if (similarity >= this.moveThreshold) {
-          if (!bestMatch || similarity > bestMatch.similarity) {
-            bestMatch = { file: createdFile, similarity };
-          }
-        }
-      }
-
-      if (bestMatch) {
-        // If we detected a move above threshold, we apply it
-        moves.push({
-          fromPath: deletedFile.path,
-          toPath: bestMatch.file.path,
-          similarity: bestMatch.similarity,
-          newContent: bestMatch.file.localContent || undefined,
-        });
-
-        // Consume the deletion and creation (move replaces both)
-        usedCreations.add(bestMatch.file.path);
-        usedDeletions.add(deletedFile.path);
-      }
-    }
-
-    const remainingChanges = changes.filter(
-      (change) =>
-        !usedCreations.has(change.path) && !usedDeletions.has(change.path)
-    );
-
-    return { moves, remainingChanges };
-  }
-
-  /**
-   * Calculate similarity between two content pieces
-   * Optimized for speed while maintaining accuracy
-   */
-  private async calculateSimilarity(
-    content1: string | Uint8Array,
-    content2: string | Uint8Array,
-    path: string
-  ): Promise<number> {
-    if (content1 === content2) return 1.0;
-
-    // Early exit: size difference too large
-    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;
-
-    // Binary files: hash mismatch = not a move
-    const isText = await isTextFile(path);
-    if (!isText) return 0.0;
-
-    // Text files: use string similarity
-    const str1 =
-      typeof content1 === "string" ? content1 : this.bufferToString(content1);
-    const str2 =
-      typeof content2 === "string" ? content2 : this.bufferToString(content2);
-
-    // For small files (<4KB), compare full content
-    if (size1 < 4096 && size2 < 4096) {
-      return stringSimilarity(str1, str2);
-    }
-
-    // For large files, sample 3 locations
-    const samples1 = this.getSamples(str1);
-    const samples2 = this.getSamples(str2);
-
-    let totalSimilarity = 0;
-    for (let i = 0; i < Math.min(samples1.length, samples2.length); i++) {
-      totalSimilarity += stringSimilarity(samples1[i], samples2[i]);
-    }
-
-    return totalSimilarity / Math.min(samples1.length, samples2.length);
-  }
-
-  /**
-   * Get representative samples from content (beginning, middle, end)
-   */
-  private getSamples(str: string): string[] {
-    const CHUNK_SIZE = 1024;
-    const length = str.length;
-
-    if (length <= CHUNK_SIZE) {
-      return [str];
-    }
-
-    return [
-      str.slice(0, CHUNK_SIZE), // Beginning
-      str.slice(
-        Math.floor(length / 2) - Math.floor(CHUNK_SIZE / 2),
-        Math.floor(length / 2) + Math.floor(CHUNK_SIZE / 2)
-      ), // Middle
-      str.slice(-CHUNK_SIZE), // End
-    ];
-  }
-
-  /**
-   * Convert buffer to string (for text comparison)
-   */
-  private bufferToString(buffer: Uint8Array): string {
-    return new TextDecoder().decode(buffer);
-  }
-
-  /**
-   * Format move for display
-   */
-  formatMove(move: MoveCandidate): string {
-    const percentage = Math.round(move.similarity * 100);
-    return `${move.fromPath} → ${move.toPath} (${percentage}% similar)`;
-  }
-}