@aprovan/patchwork 0.1.0 → 0.1.1

package/packages/compiler/src/vfs/core/types.ts

@@ -0,0 +1,93 @@
+/**
+ * File statistics matching Node.js fs.Stats subset
+ */
+export interface FileStats {
+  size: number;
+  mtime: Date;
+  isFile(): boolean;
+  isDirectory(): boolean;
+}
+
+/**
+ * Directory entry matching Node.js fs.Dirent
+ */
+export interface DirEntry {
+  name: string;
+  isFile(): boolean;
+  isDirectory(): boolean;
+}
+
+export type WatchEventType = 'create' | 'update' | 'delete';
+export type WatchCallback = (event: WatchEventType, path: string) => void;
+
+/**
+ * FSProvider - Node.js fs/promises compatible interface
+ * All paths are relative to provider root
+ */
+export interface FSProvider {
+  readFile(path: string, encoding?: 'utf8' | 'base64'): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  unlink(path: string): Promise<void>;
+  stat(path: string): Promise<FileStats>;
+  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  readdir(path: string): Promise<DirEntry[]>;
+  rmdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  watch?(path: string, callback: WatchCallback): () => void;
+}
+
+/**
+ * Change record for sync operations
+ */
+export interface ChangeRecord {
+  path: string;
+  type: WatchEventType;
+  mtime: Date;
+  checksum?: string;
+}
+
+export type ConflictStrategy =
+  | 'local-wins'
+  | 'remote-wins'
+  | 'newest-wins'
+  | 'manual';
+
+export interface SyncResult {
+  pushed: number;
+  pulled: number;
+  conflicts: ConflictRecord[];
+}
+
+export interface ConflictRecord {
+  path: string;
+  localMtime: Date;
+  remoteMtime: Date;
+  resolved?: 'local' | 'remote';
+}
+
+export type SyncStatus = 'idle' | 'syncing' | 'error';
+
+export type SyncEventType = 'change' | 'conflict' | 'error' | 'status';
+export type SyncEventCallback<T = unknown> = (data: T) => void;
+
+/**
+ * SyncEngine - orchestrates bidirectional sync
+ */
+export interface SyncEngine {
+  status: SyncStatus;
+  sync(): Promise<SyncResult>;
+  startAutoSync(intervalMs: number): void;
+  stopAutoSync(): void;
+  on<T extends SyncEventType>(
+    event: T,
+    callback: SyncEventCallback<
+      T extends 'change'
+        ? ChangeRecord
+        : T extends 'conflict'
+          ? ConflictRecord
+          : T extends 'error'
+            ? Error
+            : SyncStatus
+    >,
+  ): () => void;
+}

package/packages/compiler/src/vfs/core/utils.ts

@@ -0,0 +1,42 @@
+import type { DirEntry, FileStats } from './types.js';
+
+export function createFileStats(
+  size: number,
+  mtime: Date,
+  isDir = false,
+): FileStats {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+
+export function createDirEntry(name: string, isDir: boolean): DirEntry {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+
+export function normalizePath(path: string): string {
+  return path.replace(/\/+/g, '/').replace(/^\/|\/$/g, '');
+}
+
+export function dirname(path: string): string {
+  const normalized = normalizePath(path);
+  const lastSlash = normalized.lastIndexOf('/');
+  return lastSlash === -1 ? '' : normalized.slice(0, lastSlash);
+}
+
+export function basename(path: string): string {
+  const normalized = normalizePath(path);
+  const lastSlash = normalized.lastIndexOf('/');
+  return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
+}
+
+export function join(...parts: string[]): string {
+  return normalizePath(parts.filter(Boolean).join('/'));
+}

package/packages/compiler/src/vfs/core/virtual-fs.ts

@@ -0,0 +1,120 @@
+import type {
+  ChangeRecord,
+  DirEntry,
+  FileStats,
+  FSProvider,
+  WatchCallback,
+  WatchEventType,
+} from "./types.js";
+import { MemoryBackend } from "../backends/memory.js";
+
+type ChangeListener = (record: ChangeRecord) => void;
+
+/**
+ * VirtualFS wraps an FSProvider with change tracking.
+ * Tracks all local modifications for sync operations.
+ */
+export class VirtualFS implements FSProvider {
+  private changes = new Map<string, ChangeRecord>();
+  private listeners = new Set<ChangeListener>();
+  private backend: FSProvider;
+
+  constructor(backend?: FSProvider) {
+    this.backend = backend ?? new MemoryBackend();
+  }
+
+  async readFile(path: string, encoding?: "utf8" | "base64"): Promise<string> {
+    return this.backend.readFile(path, encoding);
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    const existed = await this.backend.exists(path);
+    await this.backend.writeFile(path, content);
+    this.recordChange(path, existed ? "update" : "create");
+  }
+
+  async applyRemoteFile(path: string, content: string): Promise<void> {
+    await this.backend.writeFile(path, content);
+  }
+
+  async applyRemoteDelete(path: string): Promise<void> {
+    try {
+      if (await this.backend.exists(path)) {
+        await this.backend.unlink(path);
+      }
+    } catch {
+      return;
+    }
+  }
+
+  async unlink(path: string): Promise<void> {
+    await this.backend.unlink(path);
+    this.recordChange(path, "delete");
+  }
+
+  async stat(path: string): Promise<FileStats> {
+    return this.backend.stat(path);
+  }
+
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    return this.backend.mkdir(path, options);
+  }
+
+  async readdir(path: string): Promise<DirEntry[]> {
+    return this.backend.readdir(path);
+  }
+
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    return this.backend.rmdir(path, options);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    return this.backend.exists(path);
+  }
+
+  watch(path: string, callback: WatchCallback): () => void {
+    if (this.backend.watch) {
+      return this.backend.watch(path, callback);
+    }
+    return () => {};
+  }
+
+  /**
+   * Get all pending changes since last sync
+   */
+  getChanges(): ChangeRecord[] {
+    return Array.from(this.changes.values());
+  }
+
+  /**
+   * Clear change tracking (after successful sync)
+   */
+  clearChanges(): void {
+    this.changes.clear();
+  }
+
+  /**
+   * Mark specific paths as synced
+   */
+  markSynced(paths: string[]): void {
+    for (const path of paths) {
+      this.changes.delete(path);
+    }
+  }
+
+  /**
+   * Subscribe to change events
+   */
+  onChange(listener: ChangeListener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private recordChange(path: string, type: WatchEventType): void {
+    const record: ChangeRecord = { path, type, mtime: new Date() };
+    this.changes.set(path, record);
+    for (const listener of this.listeners) {
+      listener(record);
+    }
+  }
+}

package/packages/compiler/src/vfs/index.ts

@@ -1,11 +1,43 @@
-export type { VirtualFile, VirtualProject, StorageBackend } from './types.js';
+// Core types and utilities
+export type {
+  ChangeRecord,
+  ConflictRecord,
+  ConflictStrategy,
+  DirEntry,
+  FileStats,
+  FSProvider,
+  SyncEngine,
+  SyncEventCallback,
+  SyncEventType,
+  SyncResult,
+  SyncStatus,
+  WatchCallback,
+  WatchEventType,
+} from './core/index.js';
+
+export {
+  basename,
+  createDirEntry,
+  createFileStats,
+  dirname,
+  join,
+  normalizePath,
+  VirtualFS,
+} from './core/index.js';
+
+// Sync engine
+export { SyncEngineImpl, type SyncEngineConfig } from './sync/index.js';
+
+// Backends
+export { MemoryBackend } from './backends/memory.js';
+export { IndexedDBBackend } from './backends/indexeddb.js';
+export { HttpBackend, type HttpBackendConfig } from './backends/http.js';
+
+export type { VirtualFile, VirtualProject } from './types.js';
 export {
   createProjectFromFiles,
   createSingleFileProject,
   resolveEntry,
   detectMainFile,
 } from './project.js';
-export { VFSStore } from './store.js';
-export { IndexedDBBackend } from './backends/indexeddb.js';
-export { LocalFSBackend, type LocalFSConfig } from './backends/local-fs.js';
-export { S3Backend, type S3Config } from './backends/s3.js';
+export { VFSStore, type VFSStoreOptions } from './store.js';

package/packages/compiler/src/vfs/project.ts

@@ -1,8 +1,8 @@
-import type { VirtualFile, VirtualProject } from './types.js';
+import type { VirtualFile, VirtualProject } from "./types.js";
 
 export function createProjectFromFiles(
   files: VirtualFile[],
-  id = crypto.randomUUID(),
+  id: string = crypto.randomUUID(),
 ): VirtualProject {
   const fileMap = new Map<string, VirtualFile>();
   for (const file of files) {
@@ -23,30 +23,30 @@ export function resolveEntry(files: Map<string, VirtualFile>): string {
   const firstTsx = paths.find((p) => /\.(tsx|jsx)$/.test(p));
   if (firstTsx) return firstTsx;
 
-  return paths[0] || 'main.tsx';
+  return paths[0] || "main.tsx";
 }
 
 export function detectMainFile(language?: string): string {
   switch (language) {
-    case 'tsx':
-    case 'typescript':
-      return 'main.tsx';
-    case 'jsx':
-    case 'javascript':
-      return 'main.jsx';
-    case 'ts':
-      return 'main.ts';
-    case 'js':
-      return 'main.js';
+    case "tsx":
+    case "typescript":
+      return "main.tsx";
+    case "jsx":
+    case "javascript":
+      return "main.jsx";
+    case "ts":
+      return "main.ts";
+    case "js":
+      return "main.js";
     default:
-      return 'main.tsx';
+      return "main.tsx";
   }
 }
 
 export function createSingleFileProject(
   content: string,
-  entry = 'main.tsx',
-  id = 'inline',
+  entry = "main.tsx",
+  id = "inline",
 ): VirtualProject {
   return {
     id,

package/packages/compiler/src/vfs/store.ts

@@ -1,31 +1,126 @@
-import type { StorageBackend, VirtualFile, VirtualProject } from './types.js';
+import type {
+  ChangeRecord,
+  ConflictRecord,
+  ConflictStrategy,
+  DirEntry,
+  FileStats,
+  FSProvider,
+  SyncEventCallback,
+  SyncEventType,
+  SyncResult,
+  SyncStatus,
+} from './core/types.js';
+import { join } from './core/utils.js';
+import { VirtualFS } from './core/virtual-fs.js';
+import { SyncEngineImpl } from './sync/index.js';
+import type { VirtualFile, VirtualProject } from './types.js';
 import { resolveEntry } from './project.js';
 
+export interface VFSStoreOptions {
+  root?: string;
+  sync?: boolean;
+  conflictStrategy?: ConflictStrategy;
+  autoSyncIntervalMs?: number;
+}
+
 export class VFSStore {
-  constructor(private backend: StorageBackend, private root = '') {}
+  private local?: VirtualFS;
+  private syncEngine?: SyncEngineImpl;
+  private root: string;
+
+  constructor(private provider: FSProvider, options: VFSStoreOptions = {}) {
+    this.root = options.root ?? '';
+
+    if (options.sync) {
+      this.local = new VirtualFS();
+      this.syncEngine = new SyncEngineImpl(this.local, this.provider, {
+        conflictStrategy: options.conflictStrategy,
+        basePath: this.root,
+      });
+      if (options.autoSyncIntervalMs) {
+        this.syncEngine.startAutoSync(options.autoSyncIntervalMs);
+      }
+    }
+  }
+
+  async readFile(path: string, encoding?: 'utf8' | 'base64'): Promise<string> {
+    if (this.local) {
+      try {
+        return await this.local.readFile(path, encoding);
+      } catch {
+        const content = await this.provider.readFile(
+          this.remotePath(path),
+          encoding,
+        );
+        await this.local.applyRemoteFile(path, content);
+        return content;
+      }
+    }
+    return this.provider.readFile(this.remotePath(path), encoding);
+  }
+
+  async writeFile(path: string, content: string): Promise<void> {
+    if (this.local) {
+      await this.local.writeFile(path, content);
+      return;
+    }
+    await this.provider.writeFile(this.remotePath(path), content);
+  }
+
+  async unlink(path: string): Promise<void> {
+    if (this.local) {
+      await this.local.unlink(path);
+      return;
+    }
+    await this.provider.unlink(this.remotePath(path));
+  }
+
+  async stat(path: string): Promise<FileStats> {
+    if (this.local) {
+      try {
+        return await this.local.stat(path);
+      } catch {
+        return this.provider.stat(this.remotePath(path));
+      }
+    }
+    return this.provider.stat(this.remotePath(path));
+  }
 
-  private key(path: string): string {
-    return this.root ? `${this.root}/${path}` : path;
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    if (this.local) {
+      await this.local.mkdir(path, options);
+    }
+    await this.provider.mkdir(this.remotePath(path), options);
   }
 
-  async getFile(path: string): Promise<VirtualFile | null> {
-    const content = await this.backend.get(this.key(path));
-    if (!content) return null;
-    return { path, content };
+  async readdir(path: string): Promise<DirEntry[]> {
+    if (this.local) {
+      try {
+        return await this.local.readdir(path);
+      } catch {
+        return this.provider.readdir(this.remotePath(path));
+      }
+    }
+    return this.provider.readdir(this.remotePath(path));
   }
 
-  async putFile(file: VirtualFile): Promise<void> {
-    await this.backend.put(this.key(file.path), file.content);
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    if (this.local) {
+      await this.local.rmdir(path, options);
+    }
+    await this.provider.rmdir(this.remotePath(path), options);
   }
 
-  async deleteFile(path: string): Promise<void> {
-    await this.backend.delete(this.key(path));
+  async exists(path: string): Promise<boolean> {
+    if (this.local) {
+      if (await this.local.exists(path)) return true;
+      return this.provider.exists(this.remotePath(path));
+    }
+    return this.provider.exists(this.remotePath(path));
   }
 
-  async listFiles(prefix?: string): Promise<string[]> {
-    const fullPrefix = prefix ? this.key(prefix) : this.root;
-    const paths = await this.backend.list(fullPrefix);
-    return paths.map((p) => (this.root ? p.slice(this.root.length + 1) : p));
+  async listFiles(prefix = ''): Promise<string[]> {
+    return this.walkFiles(prefix);
   }
 
   async loadProject(id: string): Promise<VirtualProject | null> {
@@ -35,8 +130,12 @@ export class VFSStore {
     const files = new Map<string, VirtualFile>();
     await Promise.all(
       paths.map(async (path) => {
-        const file = await this.getFile(path);
-        if (file) files.set(path.slice(id.length + 1), file);
+        const content = await this.provider.readFile(this.remotePath(path));
+        const relative = path.slice(id.length + 1);
+        files.set(relative, { path: relative, content });
+        if (this.local) {
+          await this.local.applyRemoteFile(path, content);
+        }
       }),
     );
 
@@ -44,10 +143,75 @@ export class VFSStore {
   }
 
   async saveProject(project: VirtualProject): Promise<void> {
+    if (this.local) {
+      await Promise.all(
+        Array.from(project.files.values()).map((file) =>
+          this.local!.writeFile(`${project.id}/${file.path}`, file.content),
+        ),
+      );
+      await this.sync();
+      return;
+    }
+
     await Promise.all(
       Array.from(project.files.values()).map((file) =>
-        this.putFile({ ...file, path: `${project.id}/${file.path}` }),
+        this.provider.writeFile(
+          this.remotePath(`${project.id}/${file.path}`),
+          file.content,
+        ),
       ),
     );
   }
+
+  async sync(): Promise<SyncResult> {
+    if (!this.syncEngine) {
+      return { pushed: 0, pulled: 0, conflicts: [] };
+    }
+    return this.syncEngine.sync();
+  }
+
+  on<T extends SyncEventType>(
+    event: T,
+    callback: SyncEventCallback<
+      T extends 'change'
+        ? ChangeRecord
+        : T extends 'conflict'
+          ? ConflictRecord
+          : T extends 'error'
+            ? Error
+            : SyncStatus
+    >,
+  ): () => void {
+    if (!this.syncEngine) return () => {};
+    return this.syncEngine.on(event, callback as SyncEventCallback<unknown>);
+  }
+
+  private remotePath(path: string): string {
+    return this.root ? join(this.root, path) : path;
+  }
+
+  private async walkFiles(prefix: string): Promise<string[]> {
+    const results: string[] = [];
+    const normalized = prefix ? prefix.replace(/^\/+/g, '') : '';
+
+    let entries: DirEntry[] = [];
+    try {
+      entries = await this.provider.readdir(this.remotePath(normalized));
+    } catch {
+      return results;
+    }
+
+    for (const entry of entries) {
+      const entryPath = normalized
+        ? `${normalized}/${entry.name}`
+        : entry.name;
+      if (entry.isDirectory()) {
+        results.push(...(await this.walkFiles(entryPath)));
+      } else {
+        results.push(entryPath);
+      }
+    }
+
+    return results;
+  }
 }

package/packages/compiler/src/vfs/sync/differ.ts

@@ -0,0 +1,47 @@
+import type { FSProvider } from "../core/types.js";
+
+export interface ContentChecksums {
+  local?: string;
+  remote?: string;
+}
+
+export function hashContent(content: string): string {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < content.length; i += 1) {
+    hash ^= content.charCodeAt(i);
+    hash =
+      (hash +
+        (hash << 1) +
+        (hash << 4) +
+        (hash << 7) +
+        (hash << 8) +
+        (hash << 24)) >>>
+      0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+export async function readChecksum(
+  provider: FSProvider,
+  path: string,
+): Promise<string | undefined> {
+  try {
+    const content = await provider.readFile(path);
+    return hashContent(content);
+  } catch {
+    return undefined;
+  }
+}
+
+export async function readChecksums(
+  local: FSProvider,
+  localPath: string,
+  remote: FSProvider,
+  remotePath: string,
+): Promise<ContentChecksums> {
+  const [localChecksum, remoteChecksum] = await Promise.all([
+    readChecksum(local, localPath),
+    readChecksum(remote, remotePath),
+  ]);
+  return { local: localChecksum, remote: remoteChecksum };
+}