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

package/src/utils/output.ts

@@ -1,450 +0,0 @@
-import chalk from "chalk";
-import ora, { Ora } from "ora";
-
-/**
- * Clean terminal output manager (Singleton)
- * - Progress stays on one line (spinner updates in place)
- * - No emojis
- * - Background colors for section headers
- * - Minimal output
- * - Supports scrolling task lines (max-lines)
- */
-export class Output {
-  private static instance: Output | null = null;
-  private spinner: Ora | null = null;
-  private taskStartTime: number | null = null;
-  private taskOriginalMessage: string | null = null; // Original task message for done()
-  private taskCurrentMessage: string | null = null; // Current display message (can be updated)
-  private taskLines: string[] = []; // Lines written during active task
-  private taskMaxLines: number = 0; // 0 = unlimited
-
-  private constructor() {}
-
-  /**
-   * Get the singleton instance
-   */
-  static getInstance(): Output {
-    if (!Output.instance) {
-      Output.instance = new Output();
-    }
-    return Output.instance;
-  }
-
-  /**
-   * Reset the singleton (useful for testing)
-   */
-  static reset(): void {
-    if (Output.instance?.spinner) {
-      Output.instance.spinner.stop();
-      Output.instance.spinner.clear();
-    }
-    Output.instance = null;
-  }
-
-  /**
-   * Start a task with spinner - updates in place
-   * Completes any previous task before starting the new one
-   * @param message - The task message
-   * @param maxLines - Maximum number of task lines to show (0 = unlimited, lines scroll)
-   */
-  task(message: string, maxLines: number = 0): void {
-    // Complete any existing task first
-    if (this.spinner) {
-      this.done();
-    }
-
-    this.taskStartTime = Date.now();
-    this.taskOriginalMessage = message;
-    this.taskCurrentMessage = message;
-    this.taskMaxLines = maxLines;
-    this.taskLines = [];
-    this.spinner = ora(message).start();
-  }
-
-  /**
-   * Update spinner text (stays on same line)
-   */
-  update(message: string): void {
-    if (this.spinner) {
-      this.taskCurrentMessage = message;
-      this.#updateTaskDisplay();
-    }
-  }
-
-  /**
-   * Add a line to the active task (appears below spinner, scrolls if max-lines set)
-   * Lines are dimmed and temporary - they disappear when task completes unless kept
-   * If no task is active, displays as a regular log message
-   */
-  taskLine(message: string, keepOnComplete: boolean = false): void {
-    if (!this.spinner) {
-      // No active task, just log normally as regular output
-      this.info(message);
-      return;
-    }
-
-    // Add to task lines buffer with keep flag
-    this.taskLines.push(keepOnComplete ? `[keep]${message}` : message);
-
-    // If max lines set, trim from the start (scroll)
-    if (this.taskMaxLines > 0 && this.taskLines.length > this.taskMaxLines) {
-      this.taskLines = this.taskLines.slice(-this.taskMaxLines);
-    }
-
-    this.#updateTaskDisplay();
-  }
-
-  /**
-   * Clear all task lines (useful when you want to reset the scrolling window)
-   */
-  clearTaskLines(): void {
-    this.taskLines = [];
-    this.#updateTaskDisplay();
-  }
-
-  /**
-   * Update the task display (spinner + task lines)
-   * Uses ora's multiline text support to keep spinner at top with lines below
-   */
-  #updateTaskDisplay(): void {
-    if (!this.spinner) return;
-
-    const currentText =
-      this.taskCurrentMessage || this.spinner.text.split("\n")[0] || "";
-
-    // If no task lines, show just the spinner message
-    if (this.taskLines.length === 0) {
-      this.spinner.text = currentText;
-      return;
-    }
-
-    // Build multiline text: spinner message + task lines below
-    const taskLinesText = this.taskLines
-      .map((line) => {
-        const cleanLine = line.startsWith("[keep]") ? line.slice(6) : line;
-        return chalk.dim(`  ${cleanLine}`);
-      })
-      .join("\n");
-
-    // Set spinner text to include task lines (ora handles multiline rendering)
-    this.spinner.text = `${currentText}\n${taskLinesText}`;
-  }
-
-  /**
-   * Complete task with optional duration display
-   * Defaults to showing the original task message with duration
-   * Task lines marked with keepOnComplete will be preserved, others are cleared
-   */
-  done(message?: string, showTime: boolean = true): void {
-    if (!this.spinner) return;
-
-    let text = message || this.taskOriginalMessage || "done";
-    if (showTime && this.taskStartTime) {
-      const durationMs = Date.now() - this.taskStartTime;
-      const durationText = (() => {
-        switch (true) {
-          case durationMs < 1000:
-            return `${durationMs}ms`;
-          case durationMs < 2000:
-            return `${(durationMs / 1000).toFixed(2)}s`;
-          default:
-            return `${(durationMs / 1000).toFixed(1)}s`;
-        }
-      })();
-      text += chalk.dim(` (${durationText})`);
-    }
-
-    // Clear multiline text and set to just completion message
-    this.spinner.text = text;
-    this.spinner.succeed();
-    this.spinner = null;
-
-    // Print kept task lines after completion
-    const keptLines = this.taskLines.filter((line) =>
-      line.startsWith("[keep]")
-    );
-    for (const line of keptLines) {
-      console.log(chalk.dim(`  ${line.slice(6)}`));
-    }
-
-    this.taskStartTime = null;
-    this.taskOriginalMessage = null;
-    this.taskCurrentMessage = null;
-    this.taskLines = [];
-    this.taskMaxLines = 0;
-  }
-
-  /**
-   * Show an object as a table of key-value pairs
-   * Filters out undefined values and applies optional transforms
-   * Automatically calculates key padding from max key length
-   */
-  obj(
-    obj: Record<string, any>,
-    keyTransform?: (key: string) => string,
-    valueTransform?: (value: any, key: string) => string
-  ): void {
-    this.#stopTask();
-
-    // Filter out undefined values and apply key transform
-    const entries: Array<[string, string, any]> = [];
-    for (const [key, value] of Object.entries(obj)) {
-      if (value === undefined) continue;
-      const displayKey = keyTransform ? keyTransform(key) : key;
-      entries.push([key, displayKey, value]);
-    }
-
-    // Calculate max key length for padding
-    const maxKeyLength = Math.max(
-      ...entries.map(([, displayKey]) => displayKey.length)
-    );
-
-    // Print each entry
-    for (const [key, displayKey, value] of entries) {
-      const displayValue = valueTransform
-        ? valueTransform(value, key)
-        : String(value);
-      const keyFormatted = chalk.dim(displayKey.padEnd(maxKeyLength + 2));
-      console.log(`${keyFormatted}${displayValue}`);
-    }
-  }
-
-  /**
-   * Display array as bulleted list
-   * Each item shown with dim bullet and white text
-   */
-  arr(items: any[]): void {
-    this.#stopTask();
-
-    for (const item of items) {
-      const bullet = chalk.dim("• ");
-      console.log(`${bullet}${String(item)}`);
-    }
-  }
-
-  /**
-   * Show plain message with optional color
-   */
-  log(
-    message: string,
-    color?:
-      | "red"
-      | "green"
-      | "yellow"
-      | "blue"
-      | "cyan"
-      | "magenta"
-      | "gray"
-      | "dim"
-  ): void {
-    this.#stopTask();
-
-    if (color) {
-      const colorFn = color === "dim" ? chalk.dim : chalk[color];
-      console.log(colorFn(message));
-    } else {
-      console.log(message);
-    }
-  }
-
-  /**
-   * Show success message (green text)
-   */
-  success(message: string): void {
-    this.#stopTask();
-    console.log(chalk.green(message));
-  }
-
-  /**
-   * Show success block (green background label + optional message)
-   */
-  successBlock(label: string, message: string = ""): void {
-    this.#stopTask();
-    console.log(
-      `\n${chalk.bgGreen.black(` ${label} `)}${message && ` ${message}`}`
-    );
-  }
-
-  /**
-   * Show success message (green text)
-   */
-  spicy(message: string): void {
-    this.#stopTask();
-    console.log(chalk.cyan(message));
-  }
-
-  /**
-   * Show success block (green background label + optional message)
-   */
-  spicyBlock(label: string, message: string = ""): void {
-    this.#stopTask();
-    console.log(
-      `\n${chalk.bgCyan.black(` ${label} `)}${message && ` ${message}`}`
-    );
-  }
-
-  /**
-   * Show message with rainbow gradient
-   */
-  rainbow(message: string): void {
-    this.#stopTask();
-
-    // Rainbow colors in order
-    const colors = [
-      chalk.red,
-      chalk.rgb(255, 165, 0), // orange
-      chalk.yellow,
-      chalk.green,
-      chalk.cyan,
-      chalk.blue,
-      chalk.magenta,
-    ];
-
-    const chars = message.split("");
-    const colorCount = colors.length;
-
-    // Spread colors across the string
-    const rainbow = chars
-      .map((char, i) => {
-        // Calculate which color to use based on position
-        const colorIndex = Math.floor((i / chars.length) * colorCount);
-        const color = colors[Math.min(colorIndex, colorCount - 1)];
-        return color(char);
-      })
-      .join("");
-
-    console.log(rainbow);
-  }
-
-  /**
-   * Show info message (dim text)
-   */
-  info(message: string): void {
-    this.#stopTask();
-    console.log(chalk.dim(message));
-  }
-
-  /**
-   * Show info block (grey background label + optional message)
-   */
-  infoBlock(label: string, message: string = ""): void {
-    this.#stopTask();
-    console.log(
-      `\n${chalk.bgGrey.white(` ${label} `)}${message && ` ${message}`}`
-    );
-  }
-
-  /**
-   * Show error message (red text) - fails spinner if running
-   */
-  error(message: string | Error | unknown): void {
-    if (this.spinner) {
-      this.spinner.fail("failed");
-      this.spinner = null;
-      this.taskStartTime = null;
-      this.taskOriginalMessage = null;
-      this.taskCurrentMessage = null;
-    }
-    console.log(
-      chalk.red(
-        message instanceof Error
-          ? message.message
-          : message instanceof Object
-          ? JSON.stringify(message)
-          : String(message)
-      )
-    );
-  }
-
-  /**
-   * Show error block (red background label + optional message) - fails spinner if running
-   */
-  errorBlock(label: string, message: string = ""): void {
-    if (this.spinner) {
-      this.spinner.fail("failed");
-      this.spinner = null;
-      this.taskStartTime = null;
-      this.taskOriginalMessage = null;
-      this.taskCurrentMessage = null;
-    }
-    console.log(
-      `\n${chalk.bgRed.white(` ${label} `)}${message && ` ${message}`}`
-    );
-  }
-
-  /**
-   * Show warning message (yellow text)
-   */
-  warn(message: string): void {
-    this.#stopTask();
-    console.log(chalk.yellow(message));
-  }
-
-  /**
-   * Show warning block (yellow background label + optional message)
-   */
-  warnBlock(label: string, message: string = ""): void {
-    this.#stopTask();
-    console.log(
-      `\n${chalk.bgYellow.black(` ${label} `)}${message && ` ${message}`}`
-    );
-  }
-
-  /**
-   * Show detailed error information and exit the program
-   * Use this when an unexpected/unrecoverable error occurs
-   * Shows error message and stack trace, then exits
-   */
-  crash(error: unknown, exitCode: number = 1): never {
-    this.#stopTask();
-
-    if (error instanceof Error) {
-      // Error type and message
-      console.log(chalk.red(`${error.name}: ${error.message}`));
-
-      // Stack trace
-      if (error.stack) {
-        console.log("");
-        console.log(chalk.dim("Stack trace:"));
-        const stackLines = error.stack.split("\n").slice(1); // Skip first line (error message)
-        stackLines.forEach((line) =>
-          console.log(chalk.dim(`  ${line.trim()}`))
-        );
-      }
-    } else {
-      console.log(chalk.red(String(error)));
-    }
-
-    process.exit(exitCode);
-  }
-
-  /**
-   * Exit with code
-   */
-  exit(code?: number): never {
-    this.#stopTask();
-    process.exit(code || 0);
-  }
-
-  /**
-   * Stop spinner without showing result
-   */
-  #stopTask(): void {
-    if (this.spinner) {
-      this.spinner.stop();
-      this.spinner.clear();
-      this.spinner = null;
-    }
-    this.taskStartTime = null;
-    this.taskOriginalMessage = null;
-    this.taskCurrentMessage = null;
-    this.taskLines = [];
-    this.taskMaxLines = 0;
-  }
-}
-
-/**
- * Global singleton output instance
- * Import and use this anywhere in your code
- */
-export const out = Output.getInstance();

package/src/utils/repo-factory.ts

@@ -1,73 +0,0 @@
-import "./node-polyfills.js";
-import { Repo } from "@automerge/automerge-repo";
-import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs";
-import * as subductionModule from "@automerge/automerge-subduction";
-import {
-  initSubductionModule,
-  SubductionStorageBridge,
-} from "@automerge/automerge-repo-subduction-bridge";
-import * as path from "path";
-import * as os from "os";
-import { DirectoryConfig } from "../types/index.js";
-
-const { WebCryptoSigner, Subduction } = subductionModule;
-
-let subductionModuleInitialized = false;
-
-function ensureSubductionModuleInit() {
-  if (!subductionModuleInitialized) {
-    initSubductionModule(subductionModule);
-    subductionModuleInitialized = true;
-  }
-}
-
-/**
- * Create an Automerge repository with Subduction-based setup
- */
-export async function createRepo(
-  workingDir: string,
-  config: DirectoryConfig
-): Promise<Repo> {
-  ensureSubductionModuleInit();
-
-  const syncToolDir = path.join(workingDir, ".pushwork");
-  const nodeStorage = new NodeFSStorageAdapter(path.join(syncToolDir, "automerge"));
-
-  const signer = await WebCryptoSigner.setup();
-  const storageBridge = new SubductionStorageBridge(nodeStorage);
-  const subduction = await Subduction.hydrate(signer, storageBridge);
-
-  // Connect to sync server if sync is enabled
-  if (config.sync_enabled && config.sync_server) {
-    await subduction.connectDiscover(
-      new URL(config.sync_server),
-      signer
-    );
-  }
-
-  return new Repo({ subduction } as any);
-}
-
-/**
- * Create an ephemeral Automerge repository for remote reads.
- * Uses a temporary directory for storage.
- */
-export async function createEphemeralRepo(
-  syncServer: string
-): Promise<Repo> {
-  ensureSubductionModuleInit();
-
-  const tmpDir = path.join(os.tmpdir(), `pushwork-ephemeral-${Date.now()}`);
-  const nodeStorage = new NodeFSStorageAdapter(tmpDir);
-
-  const signer = await WebCryptoSigner.setup();
-  const storageBridge = new SubductionStorageBridge(nodeStorage);
-  const subduction = await Subduction.hydrate(signer, storageBridge);
-
-  await subduction.connectDiscover(
-    new URL(syncServer),
-    signer
-  );
-
-  return new Repo({ subduction } as any);
-}

package/src/utils/string-similarity.ts

@@ -1,54 +0,0 @@
-/* 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/text-diff.ts

@@ -1,101 +0,0 @@
-import * as A from "@automerge/automerge"
-import * as diffLib from "diff"
-
-/**
- * Read content from an Automerge document, normalizing legacy ImmutableString
- * values to plain strings for backwards compatibility.
- *
- * Old documents may store text as ImmutableString. This helper ensures callers
- * always get back `string | Uint8Array | null`.
- */
-export function readDocContent(content: unknown): string | Uint8Array | null {
-	if (content == null) return null
-	if (typeof content === "string") return content
-	if (content instanceof Uint8Array) return content
-	// Legacy ImmutableString — convert to plain string
-	if (A.isImmutableString(content)) return content.toString()
-	return null
-}
-
-/**
- * Update text content on an Automerge document property inside a change
- * callback.
- *
- * If the existing value is already a collaborative text string, we diff and
- * splice for minimal CRDT operations.  If the existing value is a legacy
- * ImmutableString we can't splice into it, so we assign the whole string
- * which converts the field to a collaborative text CRDT going forward.
- *
- * @param doc  - The mutable Automerge document (inside a change callback)
- * @param path - Property path to the text field, e.g. ["content"]
- * @param newContent - The desired new text value
- */
-export function updateTextContent(
-	doc: any,
-	path: A.Prop[],
-	newContent: string
-): void {
-	const target = path.reduce((obj: any, key) => obj?.[key], doc)
-
-	if (typeof target === "string") {
-		// Already a collaborative text string — diff and splice
-		spliceText(doc, path, target, newContent)
-	} else {
-		// Legacy ImmutableString, undefined, or other — assign directly.
-		// This converts the field to a collaborative text CRDT.
-		let obj: any = doc
-		for (let i = 0; i < path.length - 1; i++) {
-			obj = obj[path[i]]
-		}
-		obj[path[path.length - 1]] = newContent
-	}
-}
-
-/**
- * Apply a text diff between oldContent and newContent as Automerge splice
- * operations on the given document property path.
- *
- * This preserves the collaborative text CRDT structure by making minimal
- * character-level edits rather than replacing the entire string.
- *
- * @param doc - The Automerge document (inside a change callback)
- * @param path - The property path to the text field, e.g. ["content"]
- * @param oldContent - The previous text content
- * @param newContent - The desired new text content
- */
-export function spliceText(
-	doc: any,
-	path: A.Prop[],
-	oldContent: string,
-	newContent: string
-): void {
-	if (oldContent === newContent) return
-
-	// Fast path: if old is empty, just insert everything
-	if (oldContent === "") {
-		A.splice(doc, path, 0, 0, newContent)
-		return
-	}
-
-	// Fast path: if new is empty, just delete everything
-	if (newContent === "") {
-		A.splice(doc, path, 0, oldContent.length)
-		return
-	}
-
-	const changes = diffLib.diffChars(oldContent, newContent)
-
-	let pos = 0
-	for (const part of changes) {
-		if (part.removed) {
-			A.splice(doc, path, pos, part.value.length)
-			// Don't advance pos — text shifted left after deletion
-		} else if (part.added) {
-			A.splice(doc, path, pos, 0, part.value)
-			pos += part.value.length
-		} else {
-			// Unchanged text — just advance the cursor
-			pos += part.value.length
-		}
-	}
-}