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

package/src/types/config.ts

@@ -1,111 +0,0 @@
-/**
- * Default sync server configuration
- */
-export const DEFAULT_SYNC_SERVER = "wss://subduction.sync.inkandswitch.com";
-
-/**
- * Global configuration options
- */
-export interface GlobalConfig {
-  sync_server?: string;
-  exclude_patterns: string[];
-  artifact_directories: string[];
-  sync: {
-    move_detection_threshold: number;
-  };
-}
-
-/**
- * Per-directory configuration
- */
-export interface DirectoryConfig extends GlobalConfig {
-  root_directory_url?: string;
-  sync_enabled: boolean;
-}
-
-/**
- * CLI command options
- */
-export interface CommandOptions {
-  verbose?: boolean;
-}
-
-/**
- * Clone command specific options
- */
-export interface CloneOptions extends CommandOptions {
-  force?: boolean; // Overwrite existing directory
-  syncServer?: string; // Custom sync server URL
-}
-
-/**
- * Sync command specific options
- */
-export interface SyncOptions extends CommandOptions {
-  force?: boolean;
-  nuclear?: boolean;
-  gentle?: boolean;
-  dryRun?: boolean;
-}
-
-/**
- * Diff command specific options
- */
-export interface DiffOptions extends CommandOptions {
-  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;
-}
-
-/**
- * Init command specific options
- */
-export interface InitOptions extends CommandOptions {
-  syncServer?: string;
-}
-
-/**
- * Config command specific options
- */
-export interface ConfigOptions extends CommandOptions {
-  list?: boolean;
-  get?: string;
-  set?: string;
-  value?: string;
-}
-
-/**
- * Status command specific options
- */
-export interface StatusOptions extends CommandOptions {
-  verbose?: boolean;
-}
-
-/**
- * Watch command specific options
- */
-export interface WatchOptions extends CommandOptions {
-  script?: string; // Script to run before syncing
-  watchDir?: string; // Directory to watch (relative to working dir)
-}
-
-/**
- * Read command specific options
- */
-export interface ReadOptions extends CommandOptions {
-  remote?: boolean; // Read from sync server instead of local storage
-}

package/src/types/documents.ts

@@ -1,91 +0,0 @@
-import {AutomergeUrl, UrlHeads} 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"}
-	name: string
-	title: string
-	docs: DirectoryEntry[]
-	lastSyncAt?: number // Timestamp of last sync operation that made changes
-	with?: string // Tool identifier that last synced, e.g. "pushwork@1.0.19"
-}
-
-/**
- * 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
-	newContent?: string | Uint8Array // Content at destination (may differ from source if modified during move)
-}
-
-/**
- * Represents a detected change
- */
-export interface DetectedChange {
-	path: string
-	changeType: ChangeType
-	fileType: FileType
-	localContent: string | Uint8Array | null
-	remoteContent: string | Uint8Array | null
-	localHead?: UrlHeads
-	remoteHead?: UrlHeads
-	/** New remote URL when the remote document was replaced (artifact URL change) */
-	remoteUrl?: AutomergeUrl
-}

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from "./documents.js";
-export * from "./snapshot.js";
-export * from "./config.js";

package/src/types/snapshot.ts

@@ -1,67 +0,0 @@
-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
-  contentHash?: string; // SHA-256 of content at last sync (used by artifact files to skip remote reads)
-}
-
-/**
- * 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[];
-  timings?: { [key: string]: number };
-}
-
-/**
- * Sync error details
- */
-export interface SyncError {
-  path: string;
-  operation: string;
-  error: Error;
-  recoverable: boolean;
-}

package/src/utils/content.ts

@@ -1,34 +0,0 @@
-import { createHash } from "crypto";
-
-/**
- * Compute a SHA-256 hash of file content.
- * Used to detect local changes for artifact files without reading remote docs.
- */
-export function contentHash(content: string | Uint8Array): string {
-  return createHash("sha256").update(content).digest("hex");
-}
-
-/**
- * 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 using native Buffer.equals() for better performance
-    const buf1 = content1 as Uint8Array;
-    const buf2 = content2 as Uint8Array;
-
-    if (buf1.length !== buf2.length) return false;
-
-    return Buffer.from(buf1).equals(Buffer.from(buf2));
-  }
-}

package/src/utils/directory.ts

@@ -1,73 +0,0 @@
-import {
-  AutomergeUrl,
-  Repo,
-  parseAutomergeUrl,
-  stringifyAutomergeUrl,
-} from "@automerge/automerge-repo";
-import { DirectoryDocument } from "../types/index.js";
-
-/**
- * Get a plain URL (without heads) from any URL.
- * Versioned URLs with heads return view handles, which show a frozen point in time.
- * For internal navigation, we always want to see the CURRENT state of documents.
- */
-export function getPlainUrl(url: AutomergeUrl): AutomergeUrl {
-  const { documentId } = parseAutomergeUrl(url);
-  return stringifyAutomergeUrl({ documentId });
-}
-
-/**
- * Find a file in the directory hierarchy by path.
- *
- * IMPORTANT: This function strips heads from all URLs before navigation.
- * This ensures we always see the CURRENT state of directories, not a frozen
- * point-in-time view. This is critical because:
- * 1. Directory documents store versioned URLs for subdirectories
- * 2. These URLs may have been captured when the subdirectory was empty
- * 3. Using versioned URLs would make files appear to not exist
- * 4. This would trigger false "remote deletion" detection
- */
-export async function findFileInDirectoryHierarchy(
-  repo: Repo,
-  directoryUrl: AutomergeUrl,
-  filePath: string
-): Promise<{ name: string; type: string; url: AutomergeUrl } | null> {
-  try {
-    const pathParts = filePath.split("/");
-    let currentDirUrl = getPlainUrl(directoryUrl);
-
-    // Navigate through directories to find the parent directory
-    for (let i = 0; i < pathParts.length - 1; i++) {
-      const dirName = pathParts[i];
-      const dirHandle = await repo.find<DirectoryDocument>(currentDirUrl);
-      const dirDoc = await dirHandle.doc();
-
-      if (!dirDoc) return null;
-
-      const subDirEntry = dirDoc.docs.find(
-        (entry: { name: string; type: string; url: AutomergeUrl }) =>
-          entry.name === dirName && entry.type === "folder"
-      );
-
-      if (!subDirEntry) return null;
-      currentDirUrl = getPlainUrl(subDirEntry.url);
-    }
-
-    // Now look for the file in the final directory
-    const fileName = pathParts[pathParts.length - 1];
-    const finalDirHandle = await repo.find<DirectoryDocument>(currentDirUrl);
-    const finalDirDoc = await finalDirHandle.doc();
-
-    if (!finalDirDoc) return null;
-
-    const fileEntry = finalDirDoc.docs.find(
-      (entry: { name: string; type: string; url: AutomergeUrl }) =>
-        entry.name === fileName && entry.type === "file"
-    );
-
-    return fileEntry || null;
-  } catch (error) {
-    // Failed to find file in hierarchy
-    return null;
-  }
-}

package/src/utils/fs.ts

@@ -1,297 +0,0 @@
-import * as fs from "fs/promises"
-import * as path from "path"
-import * as crypto from "crypto"
-import {glob} from "glob"
-import * as mimeTypes from "mime-types"
-import ignoreModule from "ignore"
-// CJS default export compat under nodenext
-const ignore = (ignoreModule as any).default || ignoreModule
-import {FileSystemEntry, FileType} from "../types/index.js"
-import {isEnhancedTextFile} from "./mime-types.js"
-
-/**
- * Check if a path exists
- */
-export async function pathExists(filePath: string): Promise<boolean> {
-	try {
-		await fs.access(filePath)
-		return true
-	} catch {
-		return false
-	}
-}
-
-/**
- * Get file system entry metadata
- */
-export async function getFileSystemEntry(
-	filePath: string
-): Promise<FileSystemEntry | null> {
-	try {
-		const stats = await fs.stat(filePath)
-		const type = stats.isDirectory()
-			? FileType.DIRECTORY
-			: (await isEnhancedTextFile(filePath))
-				? FileType.TEXT
-				: FileType.BINARY
-
-		return {
-			path: filePath,
-			type,
-			size: stats.size,
-			mtime: stats.mtime,
-			permissions: stats.mode & parseInt("777", 8),
-		}
-	} catch {
-		return null
-	}
-}
-
-/**
- * Determine if a file is text or binary
- */
-export async function isTextFile(filePath: string): Promise<boolean> {
-	try {
-		const mimeType = mimeTypes.lookup(filePath)
-		if (mimeType) {
-			return (
-				mimeType.startsWith("text/") ||
-				mimeType === "application/json" ||
-				mimeType === "application/xml" ||
-				mimeType.includes("javascript") ||
-				mimeType.includes("typescript")
-			)
-		}
-
-		// Sample first 8KB to detect binary content
-		const handle = await fs.open(filePath, "r")
-		const buffer = Buffer.alloc(Math.min(8192, (await handle.stat()).size))
-		await handle.read(buffer, 0, buffer.length, 0)
-		await handle.close()
-
-		// Check for null bytes which indicate binary content
-		return !buffer.includes(0)
-	} catch {
-		return false
-	}
-}
-
-/**
- * Read file content as string or buffer
- */
-export async function readFileContent(
-	filePath: string
-): Promise<string | Uint8Array> {
-	const isText = await isEnhancedTextFile(filePath)
-
-	if (isText) {
-		return await fs.readFile(filePath, "utf8")
-	} else {
-		const buffer = await fs.readFile(filePath)
-		return new Uint8Array(buffer)
-	}
-}
-
-/**
- * Write file content from string or buffer
- */
-export async function writeFileContent(
-	filePath: string,
-	content: string | Uint8Array
-): Promise<void> {
-	await ensureDirectoryExists(path.dirname(filePath))
-
-	if (typeof content === "string") {
-		await fs.writeFile(filePath, content, "utf8")
-	} else {
-		await fs.writeFile(filePath, content)
-	}
-}
-
-/**
- * Ensure directory exists, creating it if necessary
- */
-export async function ensureDirectoryExists(dirPath: string): Promise<void> {
-	try {
-		await fs.mkdir(dirPath, {recursive: true})
-	} catch (error: any) {
-		if (error.code !== "EEXIST") {
-			throw error
-		}
-	}
-}
-
-/**
- * Remove file or directory
- */
-export async function removePath(filePath: string): Promise<void> {
-	try {
-		const stats = await fs.stat(filePath)
-		if (stats.isDirectory()) {
-			await fs.rm(filePath, {recursive: true})
-		} else {
-			await fs.unlink(filePath)
-		}
-	} catch (error: any) {
-		if (error.code !== "ENOENT") {
-			throw error
-		}
-	}
-}
-
-/**
- * Check if a path matches any of the exclude patterns using the ignore library
- * Supports proper gitignore-style patterns (e.g., "node_modules", "*.tmp", ".git")
- */
-function isExcluded(
-	filePath: string,
-	basePath: string,
-	excludePatterns: string[]
-): boolean {
-	if (excludePatterns.length === 0) return false
-
-	const relativePath = path.relative(basePath, filePath)
-
-	// Use the ignore library which implements proper .gitignore semantics
-	// This is the same library used by ESLint and other major tools
-	const ig = ignore().add(excludePatterns)
-
-	return ig.ignores(relativePath)
-}
-
-/**
- * List directory contents with metadata
- */
-export async function listDirectory(
-	dirPath: string,
-	recursive = false,
-	excludePatterns: string[] = []
-): Promise<FileSystemEntry[]> {
-	const entries: FileSystemEntry[] = []
-
-	try {
-		// Construct pattern using path.join for proper cross-platform handling
-		const pattern = recursive
-			? path.join(dirPath, "**/*")
-			: path.join(dirPath, "*")
-
-		// glob expects forward slashes, even on Windows
-		const normalizedPattern = pattern.replace(/\\/g, "/")
-
-		// Use glob to get all paths (with dot files)
-		// Note: We don't use glob's ignore option because it doesn't support gitignore semantics
-		const paths = await glob(normalizedPattern, {
-			dot: true,
-		})
-
-		// Parallelize all stat calls for better performance
-		const allEntries = await Promise.all(
-			paths.map(async filePath => {
-				// Filter using proper gitignore semantics from the ignore library
-				if (isExcluded(filePath, dirPath, excludePatterns)) {
-					return null
-				}
-				return await getFileSystemEntry(filePath)
-			})
-		)
-
-		// Filter out null entries (excluded files or files that couldn't be read)
-		entries.push(...allEntries.filter((e): e is FileSystemEntry => e !== null))
-	} catch {
-		// Return empty array if directory doesn't exist or can't be read
-	}
-
-	return entries
-}
-
-/**
- * Copy file with metadata preservation
- */
-export async function copyFile(
-	sourcePath: string,
-	destPath: string
-): Promise<void> {
-	await ensureDirectoryExists(path.dirname(destPath))
-	await fs.copyFile(sourcePath, destPath)
-
-	// Preserve file permissions
-	const stats = await fs.stat(sourcePath)
-	await fs.chmod(destPath, stats.mode)
-}
-
-/**
- * Move/rename file or directory
- */
-export async function movePath(
-	sourcePath: string,
-	destPath: string
-): Promise<void> {
-	await ensureDirectoryExists(path.dirname(destPath))
-	await fs.rename(sourcePath, destPath)
-}
-
-/**
- * Calculate content hash for change detection
- */
-export async function calculateContentHash(
-	content: string | Uint8Array
-): Promise<string> {
-	const hash = crypto.createHash("sha256")
-	hash.update(content)
-	return hash.digest("hex")
-}
-
-/**
- * Get MIME type for file
- */
-export function getMimeType(filePath: string): string {
-	return mimeTypes.lookup(filePath) || "application/octet-stream"
-}
-
-/**
- * Get file extension
- */
-export function getFileExtension(filePath: string): string {
-	const ext = path.extname(filePath)
-	return ext.startsWith(".") ? ext.slice(1) : ext
-}
-
-/**
- * Normalize path separators for cross-platform compatibility
- * Converts all path separators to forward slashes for consistent storage
- */
-export function normalizePath(filePath: string): string {
-	return path.posix.normalize(filePath.replace(/\\/g, "/"))
-}
-
-/**
- * Join paths and normalize separators for cross-platform compatibility
- * Use this instead of string concatenation to ensure proper path handling on Windows
- */
-export function joinAndNormalizePath(...paths: string[]): string {
-	// Use path.join to properly handle path construction (handles Windows drive letters, etc.)
-	const joined = path.join(...paths)
-	// Then normalize to forward slashes for consistent storage/comparison
-	return normalizePath(joined)
-}
-
-/**
- * Get relative path from base directory
- */
-export function getRelativePath(basePath: string, filePath: string): string {
-	return normalizePath(path.relative(basePath, filePath))
-}
-
-/**
- * Format a path as a relative path with proper prefix
- * Ensures paths like "src" become "./src" for clarity
- * Leaves absolute paths and paths already starting with . or .. unchanged
- */
-export function formatRelativePath(filePath: string): string {
-	// Already starts with . or / - leave as-is
-	if (filePath.startsWith(".") || filePath.startsWith("/")) {
-		return filePath
-	}
-	// Add ./ prefix for clarity
-	return `./${filePath}`
-}

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export * from "./fs.js"
-export * from "./mime-types.js"
-export * from "./directory.js"
-export * from "./text-diff.js"