@lisang233/pi-sync 0.1.2 → 0.2.0

package/src/merge.ts

@@ -1,203 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { runGit } from "./git.js";
-import { fileHashMap, type Snapshot, snapshotFileContent } from "./snapshot.js";
-
-export interface MergeOutcome {
-	/** Files kept from the local side because only local changed. */
-	takeLocal: string[];
-	/** Files taken from the remote side because only remote changed. */
-	takeRemote: string[];
-	/** Files left with conflict markers for the user to resolve. */
-	conflicts: string[];
-	/** Files identical on both sides. */
-	unchanged: string[];
-}
-
-export interface FileMerge {
-	path: string;
-	merged: string;
-	conflicted: boolean;
-}
-
-/**
- * Three-way merge of local and remote snapshots against the base snapshot.
- * Per-file rule: unchanged files pass through, only-one-side-changed files are
- * taken from that side, and truly divergent files need a line-level merge.
- */
-export function planMerge(
-	local: Snapshot,
-	remote: Snapshot,
-	base: Snapshot | undefined,
-): MergeOutcome {
-	const localMap = fileHashMap(local);
-	const remoteMap = fileHashMap(remote);
-	const baseMap = fileHashMap(base ?? emptySnapshot());
-	const paths = [...new Set([...localMap.keys(), ...remoteMap.keys()])].sort();
-	const outcome: MergeOutcome = { takeLocal: [], takeRemote: [], conflicts: [], unchanged: [] };
-
-	for (const filePath of paths) {
-		const localHash = localMap.get(filePath);
-		const remoteHash = remoteMap.get(filePath);
-		if (localHash === remoteHash) {
-			outcome.unchanged.push(filePath);
-			continue;
-		}
-		const baseHash = baseMap.get(filePath);
-		const localChanged = localHash !== baseHash;
-		const remoteChanged = remoteHash !== baseHash;
-		if (!remoteChanged) {
-			outcome.takeLocal.push(filePath);
-			continue;
-		}
-		if (!localChanged) {
-			outcome.takeRemote.push(filePath);
-			continue;
-		}
-		outcome.conflicts.push(filePath);
-	}
-	return outcome;
-}
-
-/**
- * Line-level three-way merge of two file texts against a base using git
- * merge-file. JSON files merge field-wise first (so single-line settings
- * don't conflict over formatting); divergent values fall back to git
- * merge-file conflict markers.
- */
-export async function mergeTexts(
-	base: string,
-	local: string,
-	remote: string,
-	signal?: AbortSignal,
-): Promise<{ merged: string; conflicted: boolean }> {
-	const jsonMerged = tryJsonMerge(base, local, remote);
-	if (jsonMerged !== undefined) {
-		return { merged: jsonMerged, conflicted: false };
-	}
-	const directory = await fs.mkdtemp(path.join(os.tmpdir(), "pi-sync-merge-"));
-	try {
-		const basePath = path.join(directory, "base");
-		const localPath = path.join(directory, "local");
-		const remotePath = path.join(directory, "remote");
-		await fs.writeFile(basePath, base);
-		await fs.writeFile(localPath, local);
-		await fs.writeFile(remotePath, remote);
-		try {
-			// merge-file writes the result into the local file; it exits 1 when
-			// conflicts remain and the merged content with markers is still written.
-			await runGit(["merge-file", "--diff3", localPath, basePath, remotePath], { signal });
-		} catch (error) {
-			if (!isMergeConflictExit(error)) throw error;
-		}
-		const merged = await fs.readFile(localPath, "utf8");
-		return { merged, conflicted: hasConflictMarkers(merged) };
-	} finally {
-		await fs.rm(directory, { recursive: true, force: true });
-	}
-}
-
-/**
- * Field-level three-way merge for JSON documents. Returns undefined when the
- * documents are not all valid JSON or a value diverges on all three sides.
- */
-function tryJsonMerge(base: string, local: string, remote: string): string | undefined {
-	let baseValue: unknown;
-	let localValue: unknown;
-	let remoteValue: unknown;
-	try {
-		baseValue = JSON.parse(base);
-		localValue = JSON.parse(local);
-		remoteValue = JSON.parse(remote);
-	} catch {
-		return undefined;
-	}
-	const merged = mergeJsonValue(baseValue, localValue, remoteValue);
-	if (!merged.ok) return undefined;
-	return `${JSON.stringify(merged.value, null, 2)}\n`;
-}
-
-function mergeJsonValue(
-	base: unknown,
-	local: unknown,
-	remote: unknown,
-): { ok: true; value: unknown } | { ok: false } {
-	if (local === remote) return { ok: true, value: local };
-	if (base === local) return { ok: true, value: remote };
-	if (base === remote) return { ok: true, value: local };
-	if (isPlainObject(local) && isPlainObject(remote) && isPlainObject(base)) {
-		const keys = new Set([...Object.keys(base), ...Object.keys(local), ...Object.keys(remote)]);
-		const result: Record<string, unknown> = {};
-		for (const key of keys) {
-			const merged = mergeJsonValue(
-				(base as Record<string, unknown>)[key],
-				(local as Record<string, unknown>)[key],
-				(remote as Record<string, unknown>)[key],
-			);
-			if (!merged.ok) return { ok: false };
-			if (merged.value !== undefined) result[key] = merged.value;
-		}
-		return { ok: true, value: result };
-	}
-	return { ok: false };
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-export function hasConflictMarkers(text: string): boolean {
-	return (
-		text.includes("<<<<<<<") ||
-		text.includes(">>>>>>>") ||
-		text.includes("|||||||") ||
-		text.includes("=======")
-	);
-}
-
-function isMergeConflictExit(error: unknown): boolean {
-	return (
-		error instanceof Error &&
-		error.name === "GitCommandError" &&
-		(error as { exitCode?: number | null }).exitCode === 1
-	);
-}
-
-/**
- * Build the merged snapshot after resolving a merge plan: unchanged files pass
- * through, takeRemote files adopt the remote content, and conflict files use
- * the caller-provided merged text (falling back to local content).
- */
-export function mergeSnapshot(
-	local: Snapshot,
-	remote: Snapshot,
-	outcome: MergeOutcome,
-	conflictContents: Map<string, string> = new Map(),
-): Snapshot {
-	const adoptRemote = new Set(outcome.takeRemote);
-	const files: Snapshot["files"] = [];
-	for (const file of local.files) {
-		if (adoptRemote.has(file.path)) continue;
-		const merged = conflictContents.get(file.path);
-		if (merged !== undefined) {
-			files.push({ ...file, contentBase64: Buffer.from(merged).toString("base64") });
-			continue;
-		}
-		files.push(file);
-	}
-	for (const file of remote.files) {
-		if (adoptRemote.has(file.path)) files.push(file);
-	}
-	files.sort((left, right) => left.path.localeCompare(right.path));
-	return { version: local.version, createdAt: new Date().toISOString(), files };
-}
-
-export function emptySnapshot(): Snapshot {
-	return { version: 1, createdAt: new Date().toISOString(), files: [] };
-}
-
-/** Read a file text from any snapshot by path. */
-export function textFromSnapshot(snapshot: Snapshot, filePath: string): string {
-	return snapshotFileContent(snapshot, filePath) ?? "";
-}

package/src/resolve.ts

@@ -1,67 +0,0 @@
-import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { type MergeSessionData, saveMergeSession } from "./merge-session.js";
-
-export interface ResolveResult {
-	/** True when every block now has a resolution. */
-	completed: boolean;
-	resolved: number;
-}
-
-const KEEP_LOCAL = "keep local";
-const KEEP_REMOTE = "keep remote";
-const TYPE_REPLACEMENT = "type replacement";
-const ABORT = "abort";
-
-/**
- * Structured conflict resolution: walk the unresolved blocks one at a time and
- * let the user keep the local side, keep the remote side, or type a
- * replacement. Each block is persisted as it resolves, so an interrupted run
- * resumes from where it stopped (/sync merge).
- */
-export async function runBlockResolver(
-	ui: ExtensionUIContext,
-	session: MergeSessionData,
-): Promise<ResolveResult> {
-	const pending: Array<{ file: MergeSessionData["files"][number]; index: number }> = [];
-	for (const file of session.files) {
-		for (let index = 0; index < file.blocks.length; index += 1) {
-			if (file.blocks[index].resolution === undefined) {
-				pending.push({ file, index });
-			}
-		}
-	}
-	if (pending.length === 0) return { completed: true, resolved: 0 };
-
-	let resolved = 0;
-	for (const { file, index } of pending) {
-		const block = file.blocks[index];
-		const choice = await ui.select(`${file.path} — conflict ${index + 1}/${file.blocks.length}`, [
-			KEEP_LOCAL,
-			KEEP_REMOTE,
-			TYPE_REPLACEMENT,
-			ABORT,
-		]);
-		if (choice === undefined || choice === ABORT) {
-			await saveMergeSession(session);
-			return { completed: false, resolved };
-		}
-		if (choice === KEEP_LOCAL) {
-			block.resolution = block.local;
-			block.choice = "local";
-		} else if (choice === KEEP_REMOTE) {
-			block.resolution = block.remote;
-			block.choice = "remote";
-		} else {
-			const custom = await ui.input(`Replacement for ${file.path} block ${index + 1}`);
-			if (custom === undefined) {
-				await saveMergeSession(session);
-				return { completed: false, resolved };
-			}
-			block.resolution = custom;
-			block.choice = "custom";
-		}
-		resolved += 1;
-		await saveMergeSession(session);
-	}
-	return { completed: true, resolved };
-}

package/src/snapshot.ts

@@ -1,151 +0,0 @@
-import { createHash } from "node:crypto";
-import type { Dirent } from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import type { SyncConfig } from "./config.js";
-import { agentDir, syncRootPath } from "./paths.js";
-
-export const SNAPSHOT_VERSION = 1;
-export const MAX_SYNC_FILE_BYTES = 16 * 1024 * 1024;
-const MAX_SCAN_FILES = 5_000;
-
-export interface SnapshotFile {
-	path: string;
-	sha256: string;
-	contentBase64: string;
-}
-
-export interface Snapshot {
-	version: number;
-	createdAt: string;
-	files: SnapshotFile[];
-}
-
-export function snapshotSha256(snapshot: Snapshot): string {
-	return createHash("sha256")
-		.update(Buffer.from(JSON.stringify(snapshot)))
-		.digest("hex");
-}
-
-export function fileHashMap(snapshot: Snapshot): Map<string, string> {
-	return new Map(snapshot.files.map((file) => [file.path, file.sha256]));
-}
-
-/**
- * True when a snapshot path falls under an include entry: exact match or a
- * directory prefix, case-insensitive. This is the single include-matching
- * rule used by projection, write-back targeting and content mapping.
- */
-export function pathMatchesInclude(relativePath: string, entry: string): boolean {
-	const lower = entry.toLowerCase();
-	const pathLower = relativePath.toLowerCase();
-	return pathLower === lower || pathLower.startsWith(`${lower}/`);
-}
-
-/**
- * Project a snapshot onto the include set: keep only paths covered by the
- * declaration. The local snapshot is always a projection (`createSnapshot`
- * scans include only); remote and historical snapshots are projected before
- * merge and reporting so out-of-include leftovers never participate.
- */
-export function projectSnapshot(snapshot: Snapshot, include: string[]): Snapshot {
-	const files = snapshot.files.filter((file) =>
-		include.some((entry) => pathMatchesInclude(file.path, entry)),
-	);
-	if (files.length === snapshot.files.length) return snapshot;
-	return { ...snapshot, files };
-}
-
-/** Build the current snapshot of the configured include paths under the agent dir. */
-export async function createSnapshot(config: SyncConfig): Promise<Snapshot> {
-	const files: SnapshotFile[] = [];
-	const seen = new Set<string>();
-	for (const entry of config.include) {
-		const root = syncRootPath(entry);
-		await collectFiles(root, agentDir(), files, seen, entry);
-	}
-	files.sort((left, right) => left.path.localeCompare(right.path));
-	return { version: SNAPSHOT_VERSION, createdAt: new Date().toISOString(), files };
-}
-
-async function collectFiles(
-	root: string,
-	baseDir: string,
-	files: SnapshotFile[],
-	seen: Set<string>,
-	entry: string,
-): Promise<void> {
-	let stat: Awaited<ReturnType<typeof fs.lstat>>;
-	try {
-		stat = await fs.lstat(root);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
-	if (stat.isSymbolicLink()) return;
-	if (stat.isFile()) {
-		await collectFile(root, baseDir, files, seen, entry);
-		return;
-	}
-	if (!stat.isDirectory()) return;
-	await collectDirectory(root, baseDir, files, seen, entry);
-}
-
-async function collectDirectory(
-	directory: string,
-	baseDir: string,
-	files: SnapshotFile[],
-	seen: Set<string>,
-	entry: string,
-): Promise<void> {
-	let entries: Dirent[];
-	try {
-		entries = await fs.readdir(directory, { withFileTypes: true });
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
-	entries.sort((left, right) => left.name.localeCompare(right.name));
-	for (const dirent of entries) {
-		if (files.length >= MAX_SCAN_FILES) return;
-		if (dirent.isSymbolicLink()) continue;
-		const child = path.join(directory, dirent.name);
-		if (dirent.isDirectory()) {
-			await collectDirectory(child, baseDir, files, seen, entry);
-		} else if (dirent.isFile()) {
-			await collectFile(child, baseDir, files, seen, entry);
-		}
-	}
-}
-
-async function collectFile(
-	filePath: string,
-	baseDir: string,
-	files: SnapshotFile[],
-	seen: Set<string>,
-	_entry: string,
-): Promise<void> {
-	const stat = await fs.stat(filePath);
-	if (stat.size > MAX_SYNC_FILE_BYTES) return;
-	const content = await fs.readFile(filePath);
-	if (content.includes(0)) return;
-	const relative = path.relative(baseDir, filePath).split(path.sep).join("/");
-	if (!relative || relative.startsWith("../") || seen.has(relative)) return;
-	seen.add(relative);
-	files.push({
-		path: relative,
-		sha256: sha256Buffer(content),
-		contentBase64: content.toString("base64"),
-	});
-}
-
-function sha256Buffer(content: Buffer): string {
-	return createHash("sha256").update(content).digest("hex");
-}
-
-/** Decode snapshot file content; returns undefined for unknown paths. */
-export function snapshotFileContent(snapshot: Snapshot, filePath: string): string | undefined {
-	const file = snapshot.files.find((candidate) => candidate.path === filePath);
-	if (!file) return undefined;
-	return Buffer.from(file.contentBase64, "base64").toString("utf8");
-}

package/src/state.ts

@@ -1,60 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { stateDir } from "./config.js";
-
-const STATE_FILE_NAME = "state.json";
-const STATE_VERSION = 1;
-
-export interface SyncState {
-	version: number;
-	lastAppliedSnapshot: string;
-	lastRemoteRevision: string | undefined;
-	lastHashes: Record<string, string>;
-}
-
-export function stateFilePath(): string {
-	return path.join(stateDir(), STATE_FILE_NAME);
-}
-
-export async function loadState(): Promise<SyncState | undefined> {
-	let text: string;
-	try {
-		text = await fs.readFile(stateFilePath(), "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		return undefined;
-	}
-	return parseState(parsed);
-}
-
-export async function saveState(state: SyncState): Promise<void> {
-	await fs.mkdir(stateDir(), { recursive: true });
-	const serialized = `${JSON.stringify(state, null, "\t")}\n`;
-	await fs.writeFile(stateFilePath(), serialized, { mode: 0o600 });
-}
-
-function parseState(value: unknown): SyncState | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	if (record.version !== STATE_VERSION || typeof record.lastAppliedSnapshot !== "string") {
-		return undefined;
-	}
-	return {
-		version: STATE_VERSION,
-		lastAppliedSnapshot: record.lastAppliedSnapshot,
-		lastRemoteRevision:
-			typeof record.lastRemoteRevision === "string" ? record.lastRemoteRevision : undefined,
-		lastHashes: isHashMap(record.lastHashes) ? record.lastHashes : {},
-	};
-}
-
-function isHashMap(value: unknown): value is Record<string, string> {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	return Object.values(value).every((item) => typeof item === "string");
-}