@lisang233/pi-sync 0.1.2 → 0.2.0

package/src/status.ts

@@ -1,6 +1,3 @@
-import { planMerge } from "./merge.js";
-import type { Snapshot } from "./snapshot.js";
-
 export type SyncStateLabel =
 	| "unconfigured"
 	| "unknown"
@@ -17,41 +14,91 @@ export interface SyncStatusInfo {
 	conflicts: number;
 }
 
+export interface StateClassify {
+	label: SyncStateLabel;
+	ahead: number;
+	behind: number;
+	conflicts: number;
+	/** Paths where only the local side changed (local "wins" / pushable). */
+	localChanged: string[];
+	/** Paths where only the remote side changed (pullable). */
+	remoteChanged: string[];
+	/** Paths where both sides changed on the same path (needs a real merge). */
+	diverged: string[];
+}
+
 /**
- * Derive the sync state from the local snapshot, the remote snapshot, and the
- * base snapshot (the last remote revision we applied). A missing remote means
- * nothing has ever been published; divergent or two-sided changes are a
- * conflict, one-sided changes are ahead (push) or behind (pull).
+ * Classify the sync state by three-way comparing the agent file tree against
+ * the remote branch, using git's real merge-base as the base. Unlike the old
+ * snapshot design (which used a local state.json anchor), the base here is the
+ * true common ancestor, so a fresh machine or a rewritten remote never
+ * produces a false conflict.
+ *
+ * `base` is the content map at the merge-base (empty when there is none, e.g.
+ * a brand-new branch with no shared history). A path present in local & remote
+ * with different content and no base is conservatively a divergence.
  */
-export function deriveSyncStatus(
-	local: Snapshot,
-	remote: Snapshot | undefined,
-	base: Snapshot | undefined,
-): SyncStatusInfo {
-	if (!remote) {
-		return { label: "unpublished", ahead: 0, behind: 0, conflicts: 0 };
-	}
-	const plan = planMerge(local, remote, base);
-	if (plan.conflicts.length > 0 || (plan.takeLocal.length > 0 && plan.takeRemote.length > 0)) {
+export function classifyState(
+	local: Map<string, string>,
+	remote: Map<string, string>,
+	base: Map<string, string>,
+	mergePending: boolean,
+): StateClassify {
+	if (mergePending) {
+		const diverged = [...new Set([...local.keys(), ...remote.keys()])].filter(
+			(p) => local.get(p) !== remote.get(p),
+		);
 		return {
 			label: "conflict",
-			ahead: plan.takeLocal.length,
-			behind: plan.takeRemote.length,
-			conflicts: plan.conflicts.length,
+			ahead: 0,
+			behind: 0,
+			conflicts: diverged.length,
+			localChanged: [],
+			remoteChanged: [],
+			diverged,
 		};
 	}
-	if (plan.takeLocal.length > 0) {
-		return { label: "ahead", ahead: plan.takeLocal.length, behind: 0, conflicts: 0 };
+	const paths = [...new Set([...local.keys(), ...remote.keys()])].sort();
+	const localChanged: string[] = [];
+	const remoteChanged: string[] = [];
+	const diverged: string[] = [];
+	for (const filePath of paths) {
+		const localContent = local.get(filePath);
+		const remoteContent = remote.get(filePath);
+		if (localContent === remoteContent) continue;
+		const baseContent = base.get(filePath);
+		const localChangedSide = baseContent !== undefined ? localContent !== baseContent : true;
+		const remoteChangedSide = baseContent !== undefined ? remoteContent !== baseContent : true;
+		if (localChangedSide && remoteChangedSide) diverged.push(filePath);
+		else if (localChangedSide) localChanged.push(filePath);
+		else if (remoteChangedSide) remoteChanged.push(filePath);
 	}
-	if (plan.takeRemote.length > 0) {
-		return { label: "behind", ahead: 0, behind: plan.takeRemote.length, conflicts: 0 };
+
+	let label: SyncStateLabel;
+	if (remote.size === 0) label = "unpublished";
+	else if (diverged.length > 0 || (localChanged.length > 0 && remoteChanged.length > 0)) {
+		label = "conflict";
+	} else if (remoteChanged.length > 0) {
+		label = "behind";
+	} else if (localChanged.length > 0) {
+		label = "ahead";
+	} else {
+		label = "up-to-date";
 	}
-	return { label: "up-to-date", ahead: 0, behind: 0, conflicts: 0 };
+	return {
+		label,
+		ahead: localChanged.length,
+		behind: remoteChanged.length,
+		conflicts: diverged.length,
+		localChanged,
+		remoteChanged,
+		diverged,
+	};
 }
 
-/** Short status-bar text while a background sync (automatic fetch) is in flight. */
-export function syncBusyText(): string {
-	return "sync: fetching…";
+/** Status-bar text while a background/foreground sync action is in flight. */
+export function syncBusyText(action: "fetch" | "push" = "fetch"): string {
+	return action === "push" ? "sync: pushing…" : "sync: fetching…";
 }
 
 /** Short status-bar text for the sync indicator. */

package/src/tree.ts

@@ -0,0 +1,231 @@
+import type { Dirent } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { SyncConfig } from "./config.js";
+import { mirrorRepoDir } from "./config.js";
+import { agentDir, syncRootPath } from "./paths.js";
+
+export const MAX_SYNC_FILE_BYTES = 16 * 1024 * 1024;
+const MAX_SCAN_FILES = 5_000;
+
+export interface LocalFile {
+	/** Agent-relative posix path (e.g. "skills/x/SKILL.md"). */
+	path: string;
+	/** Absolute source path under the agent dir. */
+	source: string;
+}
+
+/**
+ * Collect the real files under the configured include paths in the agent dir.
+ * Symlinks are skipped; a path may appear under multiple include entries but is
+ * scanned once. This is the "local side" of the sync — real files, not blobs.
+ */
+export async function collectAgentFiles(config: SyncConfig): Promise<LocalFile[]> {
+	const files: LocalFile[] = [];
+	const seen = new Set<string>();
+	for (const entry of config.include) {
+		const root = syncRootPath(entry);
+		await collectRoot(root, files, seen);
+	}
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return files;
+}
+
+async function collectRoot(root: string, files: LocalFile[], seen: Set<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, files, seen);
+		return;
+	}
+	if (stat.isDirectory()) {
+		await collectDirectory(root, files, seen);
+	}
+}
+
+async function collectDirectory(
+	directory: string,
+	files: LocalFile[],
+	seen: Set<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, files, seen);
+		} else if (dirent.isFile()) {
+			await collectFile(child, files, seen);
+		}
+	}
+}
+
+async function collectFile(filePath: string, files: LocalFile[], seen: Set<string>): Promise<void> {
+	const stat = await fs.stat(filePath);
+	if (stat.size > MAX_SYNC_FILE_BYTES) return;
+	const relative = path.relative(agentDir(), filePath).split(path.sep).join("/");
+	if (!relative || relative.startsWith("../") || seen.has(relative)) return;
+	seen.add(relative);
+	files.push({ path: relative, source: filePath });
+}
+
+/** True when a relative path falls under an include entry (exact or dir prefix). */
+export function pathMatchesInclude(relativePath: string, entry: string): boolean {
+	const lower = entry.toLowerCase();
+	const pathLower = relativePath.toLowerCase();
+	return pathLower === lower || pathLower.startsWith(`${lower}/`);
+}
+
+/** Map an agent-relative path to its target inside the mirror work tree. */
+export function mirrorTarget(relativePath: string): string {
+	return path.join(mirrorRepoDir(), relativePath);
+}
+
+/** Map an agent-relative path to its absolute path under the agent dir. */
+export function agentTarget(relativePath: string): string {
+	return path.join(agentDir(), relativePath);
+}
+
+/** Read agent-file content as a path→content map for the include scope. */
+export async function readAgentContents(config: SyncConfig): Promise<Map<string, string>> {
+	const files = await collectAgentFiles(config);
+	const map = new Map<string, string>();
+	for (const file of files) {
+		try {
+			map.set(file.path, await fs.readFile(file.source, "utf8"));
+		} catch {
+			// Unreadable file — omit from the view.
+		}
+	}
+	return map;
+}
+
+/** List the agent-relative paths currently present in the mirror include scope. */
+export async function mirrorProjectedFiles(config: SyncConfig): Promise<string[]> {
+	return collectMirrorFiles(mirrorRepoDir(), config);
+}
+
+/**
+ * Overlay the agent dir's include content into the mirror work tree, deleting
+ * any mirror files under an include-subtree that no longer exist on the local
+ * side. This produces the "local side" tree for git to stage & merge.
+ */
+export async function graftAgentIntoMirror(
+	config: SyncConfig,
+	localFiles: LocalFile[],
+): Promise<void> {
+	const mirrorRoot = mirrorRepoDir();
+	for (const file of localFiles) {
+		const target = mirrorTarget(file.path);
+		await fs.mkdir(path.dirname(target), { recursive: true });
+		await fs.copyFile(file.source, target);
+	}
+	// Remove stale mirror files that are under an include path but absent locally.
+	const stale = await collectMirrorFiles(mirrorRoot, config);
+	for (const relative of stale) {
+		if (!localFiles.some((file) => file.path === relative)) {
+			await fs.rm(mirrorTarget(relative), { force: true });
+		}
+	}
+	await removeEmptyDirs(mirrorRoot);
+}
+
+/** Collect all files currently in the mirror work tree that fall under an include path. */
+async function collectMirrorFiles(mirrorRoot: string, config: SyncConfig): Promise<string[]> {
+	const result: string[] = [];
+	const seen = new Set<string>();
+	await collectMirrorRoot(mirrorRoot, "", config, result, seen);
+	return result;
+}
+
+async function collectMirrorRoot(
+	mirrorRoot: string,
+	relativeDir: string,
+	config: SyncConfig,
+	result: string[],
+	seen: Set<string>,
+): Promise<void> {
+	let entries: Dirent[];
+	try {
+		entries = await fs.readdir(path.join(mirrorRoot, relativeDir), { 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) {
+		const relative = relativeDir ? `${relativeDir}/${dirent.name}` : dirent.name;
+		if (dirent.isSymbolicLink()) continue;
+		if (dirent.isDirectory()) {
+			await collectMirrorRoot(mirrorRoot, relative, config, result, seen);
+		} else if (dirent.isFile()) {
+			if (!config.include.some((entry) => pathMatchesInclude(relative, entry))) continue;
+			if (seen.has(relative)) continue;
+			seen.add(relative);
+			result.push(relative);
+		}
+	}
+}
+
+/** Remove now-empty directories under the mirror root, bottom-up. */
+async function removeEmptyDirs(root: string): Promise<void> {
+	const dirs: string[] = [];
+	const walk = async (dir: string): Promise<void> => {
+		let entries: Dirent[];
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const dirent of entries) {
+			if (dirent.isDirectory()) await walk(path.join(dir, dirent.name));
+		}
+		dirs.push(dir);
+	};
+	await walk(root);
+	for (const dir of dirs.reverse()) {
+		if (dir === root) continue;
+		try {
+			const entries = await fs.readdir(dir);
+			if (entries.length === 0) await fs.rmdir(dir);
+		} catch {
+			// ignore
+		}
+	}
+}
+
+/**
+ * Apply the mirror work tree to the agent dir: copy include-scoped files over
+ * and delete agent files under an include path that are absent from the mirror.
+ */
+export async function copyMirrorToAgent(config: SyncConfig): Promise<void> {
+	const mirrorRoot = mirrorRepoDir();
+	const projected = await mirrorProjectedFiles(config);
+	for (const relative of projected) {
+		const source = path.join(mirrorRoot, relative);
+		const target = agentTarget(relative);
+		await fs.mkdir(path.dirname(target), { recursive: true });
+		await fs.copyFile(source, target);
+	}
+	// Delete agent files under an include path that are absent from the mirror.
+	const localFiles = await collectAgentFiles(config);
+	const projectedSet = new Set(projected);
+	for (const file of localFiles) {
+		if (projectedSet.has(file.path)) continue;
+		await fs.rm(file.source, { force: true });
+	}
+}

package/src/conflict.ts

@@ -1,90 +0,0 @@
-import type { ConflictBlock } from "./merge-session.js";
-
-/** A parsed diff3 conflict block with its line span in the merged text. */
-export interface ParsedConflictBlock {
-	block: ConflictBlock;
-	/** Line index of the "<<<<<<<" marker. */
-	startLine: number;
-	/** Line index of the ">>>>>>>" marker (inclusive). */
-	endLine: number;
-}
-
-const MARKER_OPEN = "<<<<<<<";
-const MARKER_BASE = "|||||||";
-const MARKER_SEP = "=======";
-const MARKER_CLOSE = ">>>>>>>";
-
-/**
- * Parse diff3 conflict markers (as written by `git merge-file --diff3`) into
- * independent blocks. Malformed blocks are skipped rather than failing the
- * whole file. Marker labels (anything after the marker prefix) are ignored.
- */
-export function parseConflictBlocks(mergedText: string): ParsedConflictBlock[] {
-	const lines = mergedText.split(/\r?\n/u);
-	const blocks: ParsedConflictBlock[] = [];
-	let index = 0;
-	while (index < lines.length) {
-		if (lines[index].startsWith(MARKER_OPEN)) {
-			const startLine = index;
-			const localEnd = findMarker(lines, index + 1, [MARKER_BASE, MARKER_SEP, MARKER_CLOSE]);
-			if (localEnd === undefined) break;
-			const baseStart = localEnd;
-			const baseEnd = findMarker(lines, baseStart + 1, [MARKER_SEP, MARKER_CLOSE]);
-			if (baseEnd === undefined) break;
-			const sep = baseEnd;
-			const remoteEnd = findMarker(lines, sep + 1, [MARKER_CLOSE]);
-			if (remoteEnd === undefined) break;
-			blocks.push({
-				block: {
-					local: lines.slice(startLine + 1, localEnd).join("\n"),
-					base: lines.slice(baseStart + 1, sep).join("\n"),
-					remote: lines.slice(sep + 1, remoteEnd).join("\n"),
-					resolution: undefined,
-					choice: undefined,
-				},
-				startLine,
-				endLine: remoteEnd,
-			});
-			index = remoteEnd + 1;
-			continue;
-		}
-		index += 1;
-	}
-	return blocks;
-}
-
-/**
- * Rebuild the merged text with conflict blocks replaced by their resolutions.
- * `resolutions[i]` is the resolved content for block i; undefined is an error.
- * Preserves the merged text's line-ending style.
- */
-export function applyResolutions(
-	mergedText: string,
-	resolutions: Array<string | undefined>,
-): string {
-	const eol = mergedText.includes("\r\n") ? "\r\n" : "\n";
-	const lines = mergedText.split(/\r?\n/u);
-	const blocks = parseConflictBlocks(mergedText);
-	if (blocks.length !== resolutions.length) {
-		throw new Error(
-			`Conflict block count changed (${blocks.length} on disk vs ${resolutions.length} in session). Re-run /sync pull --merge or /sync merge --abort.`,
-		);
-	}
-	for (let index = blocks.length - 1; index >= 0; index -= 1) {
-		const resolution = resolutions[index];
-		if (resolution === undefined) {
-			throw new Error(`Conflict block ${index + 1} is not resolved yet.`);
-		}
-		const block = blocks[index];
-		const replacement = resolution.split(/\r?\n/u);
-		lines.splice(block.startLine, block.endLine - block.startLine + 1, ...replacement);
-	}
-	return lines.join(eol);
-}
-
-function findMarker(lines: string[], from: number, markers: string[]): number | undefined {
-	for (let index = from; index < lines.length; index += 1) {
-		if (markers.some((marker) => lines[index].startsWith(marker))) return index;
-	}
-	return undefined;
-}

package/src/merge-session.ts

@@ -1,145 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { stateDir } from "./config.js";
-
-const SESSION_DIR = "merge-session";
-const SESSION_FILE = "session.json";
-
-export type BlockChoice = "local" | "remote" | "custom";
-
-/** One divergent block from a merged file; resolution is set when the user resolves it. */
-export interface ConflictBlock {
-	local: string;
-	base: string;
-	remote: string;
-	resolution: string | undefined;
-	choice: BlockChoice | undefined;
-}
-
-export interface MergeFileState {
-	path: string;
-	/** The full merged text with diff3 markers (resume needs no disk state). */
-	merged: string;
-	blocks: ConflictBlock[];
-}
-
-/**
- * The persistent state of one conflict-resolution session. Lives in its own
- * file (block contents can be large) so state.json stays small and backward
- * compatible; only the presence of this file marks an incomplete merge.
- */
-export interface MergeSessionData {
-	baselineRevision: string;
-	backupDir: string;
-	createdAt: string;
-	/** Files taken from the remote side when the session started. */
-	takeRemote: number;
-	/** Files kept from the local side when the session started. */
-	takeLocal: number;
-	files: MergeFileState[];
-}
-
-export function mergeSessionDir(): string {
-	return path.join(stateDir(), SESSION_DIR);
-}
-
-export function mergeSessionFilePath(): string {
-	return path.join(mergeSessionDir(), SESSION_FILE);
-}
-
-export async function loadMergeSession(): Promise<MergeSessionData | undefined> {
-	let text: string;
-	try {
-		text = await fs.readFile(mergeSessionFilePath(), "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-	try {
-		return parseMergeSession(JSON.parse(text));
-	} catch {
-		return undefined;
-	}
-}
-
-export async function saveMergeSession(session: MergeSessionData): Promise<void> {
-	await fs.mkdir(mergeSessionDir(), { recursive: true });
-	const serialized = `${JSON.stringify(session, null, "\t")}\n`;
-	await fs.writeFile(mergeSessionFilePath(), serialized, { mode: 0o600 });
-}
-
-export async function clearMergeSession(): Promise<void> {
-	await fs.rm(mergeSessionDir(), { recursive: true, force: true });
-}
-
-/** True when a merge session file exists and parses. */
-export async function hasMergeSession(): Promise<boolean> {
-	return (await loadMergeSession()) !== undefined;
-}
-
-function parseMergeSession(value: unknown): MergeSessionData | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	if (
-		typeof record.baselineRevision !== "string" ||
-		typeof record.backupDir !== "string" ||
-		typeof record.createdAt !== "string" ||
-		typeof record.takeRemote !== "number" ||
-		typeof record.takeLocal !== "number" ||
-		!Array.isArray(record.files)
-	) {
-		return undefined;
-	}
-	const files: MergeFileState[] = [];
-	for (const file of record.files) {
-		const parsed = parseMergeFile(file);
-		if (!parsed) return undefined;
-		files.push(parsed);
-	}
-	return {
-		baselineRevision: record.baselineRevision,
-		backupDir: record.backupDir,
-		createdAt: record.createdAt,
-		takeRemote: record.takeRemote,
-		takeLocal: record.takeLocal,
-		files,
-	};
-}
-
-function parseMergeFile(value: unknown): MergeFileState | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	if (
-		typeof record.path !== "string" ||
-		typeof record.merged !== "string" ||
-		!Array.isArray(record.blocks)
-	) {
-		return undefined;
-	}
-	const blocks: ConflictBlock[] = [];
-	for (const block of record.blocks) {
-		const parsed = parseBlock(block);
-		if (!parsed) return undefined;
-		blocks.push(parsed);
-	}
-	return { path: record.path, merged: record.merged, blocks };
-}
-
-function parseBlock(value: unknown): ConflictBlock | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	if (
-		typeof record.local !== "string" ||
-		typeof record.base !== "string" ||
-		typeof record.remote !== "string"
-	) {
-		return undefined;
-	}
-	const resolution = record.resolution ?? undefined;
-	if (resolution !== undefined && typeof resolution !== "string") return undefined;
-	const choice = record.choice ?? undefined;
-	if (choice !== undefined && choice !== "local" && choice !== "remote" && choice !== "custom") {
-		return undefined;
-	}
-	return { local: record.local, base: record.base, remote: record.remote, resolution, choice };
-}