pushwork 1.0.4 → 1.0.7

package/src/utils/repo-factory.ts

@@ -2,56 +2,38 @@ import { Repo, StorageId } from "@automerge/automerge-repo";
 import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs";
 import { BrowserWebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
 import * as path from "path";
-import chalk from "chalk";
-import { ConfigManager } from "../config";
-
-export interface RepoFactoryOptions {
-  enableNetwork?: boolean;
-  syncServer?: string;
-  syncServerStorageId?: string;
-}
+import { DirectoryConfig } from "../types";
 
 /**
  * Create an Automerge repository with configuration-based setup
  */
 export async function createRepo(
   workingDir: string,
-  options: RepoFactoryOptions = {}
+  config: DirectoryConfig
 ): Promise<Repo> {
-  const configManager = new ConfigManager(workingDir);
-  const config = await configManager.getMerged();
-
   const syncToolDir = path.join(workingDir, ".pushwork");
   const storage = new NodeFSStorageAdapter(path.join(syncToolDir, "automerge"));
 
   const repoConfig: any = { storage };
 
-  // Determine network settings - options override config
-  const enableNetwork = options.enableNetwork ?? true;
-  const syncServer = options.syncServer ?? config.sync_server;
-  const syncServerStorageId =
-    options.syncServerStorageId ?? config.sync_server_storage_id;
-
-  // Add network adapter only if explicitly enabled and sync server is configured
-  if (enableNetwork && syncServer) {
-    const networkAdapter = new BrowserWebSocketClientAdapter(syncServer);
+  // Add network adapter only if sync is enabled and server is configured
+  if (config.sync_enabled && config.sync_server) {
+    const networkAdapter = new BrowserWebSocketClientAdapter(
+      config.sync_server
+    );
     repoConfig.network = [networkAdapter];
     repoConfig.enableRemoteHeadsGossiping = true;
-    console.log(chalk.gray(`  ✓ Network sync enabled: ${syncServer}`));
-  } else {
-    console.log(chalk.gray("  ✓ Local-only mode (network sync disabled)"));
   }
 
   const repo = new Repo(repoConfig);
 
   // Subscribe to the sync server storage for network sync
-  if (enableNetwork && syncServer && syncServerStorageId) {
-    repo.subscribeToRemotes([syncServerStorageId as StorageId]);
-    console.log(
-      chalk.gray(
-        `  ✓ Subscribed to sync server storage: ${syncServerStorageId}`
-      )
-    );
+  if (
+    config.sync_enabled &&
+    config.sync_server &&
+    config.sync_server_storage_id
+  ) {
+    repo.subscribeToRemotes([config.sync_server_storage_id as StorageId]);
   }
 
   return repo;

package/src/utils/string-similarity.ts

@@ -0,0 +1,54 @@
+/* Based on the Sørensen–Dice coefficient, code from https://github.com/stephenjjbrown/string-similarity-js */
+
+/**
+
+ * Calculate similarity between two strings
+
+ * @param {string} str1 First string to match
+ * @param {string} str2 Second string to match
+ * @param {number} [substringLength=2] Optional. Length of substring to be used in calculating similarity. Default 2.
+ * @param {boolean} [caseSensitive=false] Optional. Whether you want to consider case in string matching. Default false;
+
+ * @returns Number between 0 and 1, with 0 being a low match score.
+
+ */
+
+export const stringSimilarity = (
+  str1: string,
+  str2: string,
+  substringLength: number = 2,
+  caseSensitive: boolean = false
+) => {
+  if (str1 === str2) return 1;
+  if (!caseSensitive) {
+    str1 = str1.toLowerCase();
+
+    str2 = str2.toLowerCase();
+  }
+
+  if (str1.length < substringLength || str2.length < substringLength) return 0;
+
+  const map = new Map();
+
+  for (let i = 0; i < str1.length - (substringLength - 1); i++) {
+    const substr1 = str1.substring(i, i + substringLength);
+
+    map.set(substr1, map.has(substr1) ? map.get(substr1) + 1 : 1);
+  }
+
+  let match = 0;
+
+  for (let j = 0; j < str2.length - (substringLength - 1); j++) {
+    const substr2 = str2.substring(j, j + substringLength);
+
+    const count = map.has(substr2) ? map.get(substr2) : 0;
+
+    if (count > 0) {
+      map.set(substr2, count - 1);
+
+      match++;
+    }
+  }
+
+  return (match * 2) / (str1.length + str2.length - (substringLength - 1) * 2);
+};

package/src/utils/trace.ts

@@ -0,0 +1,70 @@
+import { out } from "./output";
+
+/**
+ * Global tracing state
+ */
+let tracingEnabled = false;
+
+/**
+ * Enable or disable tracing
+ */
+export function setTracingEnabled(enabled: boolean): void {
+  tracingEnabled = enabled;
+}
+
+/**
+ * Check if tracing is enabled
+ */
+export function isTracingEnabled(): boolean {
+  return tracingEnabled;
+}
+
+/**
+ * Trace a span of work by outputting to console
+ * Works for both sync and async functions
+ * Only outputs if tracing is enabled
+ *
+ * Usage:
+ *   await span("operation", async () => { ... })
+ *   span("operation", () => { ... })
+ */
+export function span<T>(
+  name: string,
+  fn: () => T | Promise<T>
+): T | Promise<T> {
+  if (!tracingEnabled) {
+    return fn();
+  }
+
+  const start = performance.now();
+  const result = fn();
+
+  // Check if it's a promise (async)
+  if (result instanceof Promise) {
+    return result.then((value) => {
+      const duration = performance.now() - start;
+      out.taskLine(`${name} (${formatDuration(duration)})`, true);
+      return value;
+    }) as T;
+  }
+
+  // Sync case
+  const duration = performance.now() - start;
+  out.taskLine(`${name} (${formatDuration(duration)})`, true);
+  return result;
+}
+
+/**
+ * Format duration for display
+ */
+function formatDuration(ms: number): string {
+  if (ms < 1) {
+    return `${ms.toFixed(2)}ms`;
+  } else if (ms < 1000) {
+    return `${Math.round(ms)}ms`;
+  } else if (ms < 2000) {
+    return `${(ms / 1000).toFixed(2)}s`;
+  } else {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+}

package/test/integration/exclude-patterns.test.ts

@@ -1,7 +1,7 @@
 import * as path from "path";
 import * as fs from "fs/promises";
 import { tmpdir } from "os";
-import { ConfigManager } from "../../src/config";
+import { ConfigManager } from "../../src/core";
 import { DirectoryConfig } from "../../src/types";
 import {
   ensureDirectoryExists,
@@ -105,18 +105,9 @@ describe("Exclude Patterns", () => {
     const localConfig: DirectoryConfig = {
       sync_server: "wss://test.server.com",
       sync_enabled: true,
-      defaults: {
-        exclude_patterns: [".git", "*.tmp", ".pushwork", "*.env"],
-        large_file_threshold: "100MB",
-      },
-      diff: {
-        show_binary: false,
-      },
+      exclude_patterns: [".git", "*.tmp", ".pushwork", "*.env"],
       sync: {
         move_detection_threshold: 0.8,
-        prompt_threshold: 0.5,
-        auto_sync: false,
-        parallel_operations: 4,
       },
     };
     await configManager.save(localConfig);
@@ -125,9 +116,9 @@ describe("Exclude Patterns", () => {
     const mergedConfig = await configManager.getMerged();
 
     // Verify .pushwork is in the exclude patterns
-    expect(mergedConfig.defaults.exclude_patterns).toContain(".pushwork");
-    expect(mergedConfig.defaults.exclude_patterns).toContain("*.env");
-    expect(mergedConfig.defaults.exclude_patterns).toContain(".git");
+    expect(mergedConfig.exclude_patterns).toContain(".pushwork");
+    expect(mergedConfig.exclude_patterns).toContain("*.env");
+    expect(mergedConfig.exclude_patterns).toContain(".git");
 
     // Create test files
     await writeFileContent(path.join(tmpDir, "include.txt"), "include me");
@@ -141,7 +132,7 @@ describe("Exclude Patterns", () => {
     const entries = await listDirectory(
       tmpDir,
       true,
-      mergedConfig.defaults.exclude_patterns
+      mergedConfig.exclude_patterns
     );
     const filePaths = entries.map((entry) => path.relative(tmpDir, entry.path));