@lisang233/pi-sync 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lisang233/pi-sync",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "Personal Pi extension that syncs Pi configuration through Git with background auto-sync and git-style fetch/merge conflict handling.",
 	"type": "module",
 	"license": "MIT",

package/src/extension.ts

@@ -3,9 +3,10 @@ import type {
 	ExtensionCommandContext,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { loadConfig } from "./config.js";
+import { loadConfig, type SyncConfig } from "./config.js";
 import { runConfigEditor } from "./config-ui.js";
 import * as operations from "./operations.js";
+import { syncBusyText } from "./status.js";
 import { runSetupWizard } from "./wizard.js";
 
 const STATUS_KEY = "sync";
@@ -37,8 +38,12 @@ const USAGE = [
 export default function sync(pi: ExtensionAPI): void {
 	let sessionAbort = new AbortController();
 	let backgroundSync: BackgroundSync | undefined;
+	let backgroundPush: BackgroundSync | undefined;
 
 	const startBackgroundSync = (ctx: ExtensionContext, signal: AbortSignal) => {
+		// While the automatic fetch is in flight the indicator shows the busy
+		// state; refreshIndicator replaces it with the real state when done.
+		ctx.ui.setStatus(STATUS_KEY, syncBusyText());
 		const settled = (async () => {
 			try {
 				await runAutomaticSync(ctx, signal);
@@ -51,15 +56,42 @@ export default function sync(pi: ExtensionAPI): void {
 		backgroundSync = { settled };
 	};
 
-	const drainBackgroundSync = async (signal?: AbortSignal): Promise<void> => {
-		const current = backgroundSync;
+	// Publish in the background so the TUI stays interactive while git talks
+	// to the remote (fetch + push can take many seconds). The indicator shows
+	// "pushing…"; operations.push notifies the outcome when it settles.
+	const startBackgroundPush = (
+		ctx: ExtensionCommandContext,
+		config: SyncConfig,
+		force: boolean,
+		signal: AbortSignal,
+	) => {
+		ctx.ui.setStatus(STATUS_KEY, syncBusyText("push"));
+		const settled = (async () => {
+			try {
+				await operations.push(ctx, config, { force });
+			} catch (error) {
+				if (signal.aborted) return;
+				ctx.ui.setStatus(STATUS_KEY, undefined);
+				ctx.ui.notify(`pi-sync push failed: ${errorMessage(error)}`, "error");
+			}
+		})();
+		backgroundPush = { settled };
+	};
+
+	const drainBackgroundTasks = async (signal?: AbortSignal): Promise<void> => {
+		const tasks = [backgroundSync, backgroundPush];
 		backgroundSync = undefined;
-		if (!current) return;
-		try {
-			await (signal ? Promise.race([current.settled, waitForAbort(signal)]) : current.settled);
-		} catch {
-			// The shutdown deadline or a replacement aborted while draining; the
-			// background sync observes its own session signal and settles on its own.
+		backgroundPush = undefined;
+		for (const current of tasks) {
+			if (!current) continue;
+			try {
+				await (signal
+					? Promise.race([current.settled, waitForAbort(signal)])
+					: current.settled);
+			} catch {
+				// The shutdown deadline or a replacement aborted while draining; the
+				// background task observes its own session signal and settles on its own.
+			}
 		}
 	};
 
@@ -80,7 +112,18 @@ export default function sync(pi: ExtensionAPI): void {
 				);
 			}
 			try {
-				await handleCommand(args, ctx);
+				await handleCommand(args, ctx, async (pushCtx, config, force) => {
+					if (backgroundPush) {
+						pushCtx.ui.notify("A push is already in progress.", "warning");
+						return;
+					}
+					// Wait for the session-start automatic fetch so the two
+					// background tasks never contend on the mirror repo, then run
+					// the publish without blocking the TUI.
+					await drainBackgroundTasks();
+					if (sessionAbort.signal.aborted) return;
+					startBackgroundPush(pushCtx, config, force, sessionAbort.signal);
+				});
 			} catch (error) {
 				if (sessionAbort.signal.aborted) return;
 				ctx.ui.setStatus(STATUS_KEY, undefined);
@@ -94,7 +137,7 @@ export default function sync(pi: ExtensionAPI): void {
 		sessionAbort = new AbortController();
 		const signal = sessionAbort.signal;
 		ctx.ui.setStatus(STATUS_KEY, undefined);
-		await drainBackgroundSync();
+		await drainBackgroundTasks();
 		try {
 			const config = await loadConfig();
 			if (signal.aborted) return;
@@ -122,7 +165,15 @@ async function runAutomaticSync(ctx: ExtensionContext, signal: AbortSignal): Pro
 	await operations.fetch(ctx, config, { quiet: true });
 }
 
-async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext): Promise<void> {
+async function handleCommand(
+	rawArgs: string,
+	ctx: ExtensionCommandContext,
+	runPush: (
+		ctx: ExtensionCommandContext,
+		config: SyncConfig,
+		force: boolean,
+	) => Promise<void>,
+): Promise<void> {
 	const [first = "", ...restTokens] = rawArgs.trim().split(/\s+/u);
 	const subcommand = normalizeSubcommand(first);
 	if (subcommand === undefined || subcommand === "help") {
@@ -155,7 +206,7 @@ async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext): Pro
 			});
 			return;
 		case "push":
-			await operations.push(ctx, config, { force });
+			await runPush(ctx, config, force);
 			return;
 		case "pull":
 			await operations.pull(ctx, config, {

package/src/operations.ts

@@ -35,7 +35,13 @@ import {
 } from "./merge-session.js";
 import { agentDir, syncRootPath } from "./paths.js";
 import { runBlockResolver } from "./resolve.js";
-import { createSnapshot, type Snapshot, snapshotSha256 } from "./snapshot.js";
+import {
+	createSnapshot,
+	pathMatchesInclude,
+	projectSnapshot,
+	type Snapshot,
+	snapshotSha256,
+} from "./snapshot.js";
 import { loadState, saveState } from "./state.js";
 import { deriveSyncStatus, type SyncStatusInfo, syncIndicatorText } from "./status.js";
 
@@ -65,10 +71,15 @@ export async function refreshIndicator(ctx: OperationContext, config: SyncConfig
 			readRemoteSnapshot(config),
 			loadState(),
 		]);
+		const projectedRemote = remote ? projectSnapshot(remote, config.include) : undefined;
 		const base = state?.lastRemoteRevision
 			? await readSnapshotAt(state.lastRemoteRevision, { signal: ctx.signal })
 			: undefined;
-		ctx.ui.setStatus("sync", syncIndicatorText(deriveSyncStatus(local, remote, base)));
+		const projectedBase = base ? projectSnapshot(base, config.include) : undefined;
+		ctx.ui.setStatus(
+			"sync",
+			syncIndicatorText(deriveSyncStatus(local, projectedRemote, projectedBase)),
+		);
 	} catch {
 		ctx.ui.setStatus(
 			"sync",
@@ -90,10 +101,12 @@ export async function status(
 		readRemoteSnapshot(config),
 		loadState(),
 	]);
+	const projectedRemote = remote ? projectSnapshot(remote, config.include) : undefined;
 	const base = state?.lastRemoteRevision
 		? await readSnapshotAt(state.lastRemoteRevision, { signal: ctx.signal })
 		: undefined;
-	const info = deriveSyncStatus(local, remote, base);
+	const projectedBase = base ? projectSnapshot(base, config.include) : undefined;
+	const info = deriveSyncStatus(local, projectedRemote, projectedBase);
 	const mergeSession = await loadMergeSession();
 	await refreshIndicator(ctx, config);
 	const lines = [
@@ -107,8 +120,8 @@ export async function status(
 		);
 	}
 	lines.push(nextStepHint(info, mergeSession !== undefined));
-	if (options.diff && remote) {
-		lines.push("", formatSnapshotDiff(local, remote));
+	if (options.diff && projectedRemote) {
+		lines.push("", formatSnapshotDiff(local, projectedRemote));
 	}
 	const level = info.label === "up-to-date" && !mergeSession ? "info" : "warning";
 	ctx.ui.notify(lines.join("\n"), level);
@@ -196,10 +209,12 @@ export async function pull(
 		ctx.ui.notify(message, "warning");
 		return { pushed: false, pulled: false, merged: false, message };
 	}
+	const projectedRemote = projectSnapshot(remote, config.include);
 	const base = state?.lastRemoteRevision
 		? await readSnapshotAt(state.lastRemoteRevision, { signal: ctx.signal })
 		: undefined;
-	const plan = planMerge(local, remote, base);
+	const projectedBase = base ? projectSnapshot(base, config.include) : undefined;
+	const plan = planMerge(local, projectedRemote, projectedBase);
 	const diverged =
 		plan.conflicts.length > 0 || (plan.takeLocal.length > 0 && plan.takeRemote.length > 0);
 
@@ -214,7 +229,7 @@ export async function pull(
 			return { pushed: false, pulled: false, merged: false, message };
 		}
 		// Fast-forward: apply the merged snapshot (remote-only changes).
-		const merged = mergeSnapshot(local, remote, plan);
+		const merged = mergeSnapshot(local, projectedRemote, plan);
 		await applySnapshot(merged, config);
 		await saveState({
 			version: 1,
@@ -231,22 +246,30 @@ export async function pull(
 
 	if (options.force) {
 		const backup = await backupLocalFiles(local);
-		await applySnapshot(remote, config);
+		await applySnapshot(projectedRemote, config);
 		await saveState({
 			version: 1,
-			lastAppliedSnapshot: snapshotSha256(remote),
+			lastAppliedSnapshot: snapshotSha256(projectedRemote),
 			lastRemoteRevision: remoteRevision,
-			lastHashes: Object.fromEntries(remote.files.map((file) => [file.path, file.sha256])),
+			lastHashes: Object.fromEntries(projectedRemote.files.map((file) => [file.path, file.sha256])),
 		});
 		await clearMergeSession();
 		await refreshIndicator(ctx, config);
-		const message = `Overwrote local files with the remote snapshot (${remote.files.length} files). Backup: ${backup}`;
+		const message = `Overwrote local files with the remote snapshot (${projectedRemote.files.length} files). Backup: ${backup}`;
 		ctx.ui.notify(message, "warning");
 		return { pushed: false, pulled: true, merged: false, message };
 	}
 
 	if (options.merge) {
-		return startMergeFlow(ctx, config, local, remote, base, plan, remoteRevision ?? "");
+		return startMergeFlow(
+			ctx,
+			config,
+			local,
+			projectedRemote,
+			projectedBase,
+			plan,
+			remoteRevision ?? "",
+		);
 	}
 
 	const message =
@@ -402,14 +425,15 @@ export async function fetch(
 		readRemoteRevision(config),
 		createSnapshot(config),
 	]);
+	const projectedRemote = remote ? projectSnapshot(remote, config.include) : undefined;
 	await refreshIndicator(ctx, config);
-	if (!remote) {
+	if (!projectedRemote) {
 		const message = "Remote is empty. Run /sync push to publish local content.";
 		if (!options.quiet) ctx.ui.notify(message, "info");
 		return { pushed: false, pulled: false, merged: false, message };
 	}
-	const summary = diffSummary(local, remote);
-	const message = `Fetched ${remote.files.length} files from ${config.branch} (${shortId(remoteRevision ?? "")}). ${describeChanges(summary)}.`;
+	const summary = diffSummary(local, projectedRemote);
+	const message = `Fetched ${projectedRemote.files.length} files from ${config.branch} (${shortId(remoteRevision ?? "")}). ${describeChanges(summary)}.`;
 	if (!options.quiet) ctx.ui.notify(message, summary.identical ? "info" : "warning");
 	return { pushed: false, pulled: false, merged: false, message };
 }
@@ -489,12 +513,7 @@ export async function applySnapshot(snapshot: Snapshot, config: SyncConfig): Pro
 
 function resolveSnapshotTarget(relativePath: string, config: SyncConfig): string | undefined {
 	if (relativePath.split("/").some((segment) => segment === "..")) return undefined;
-	const entry = config.include.find((candidate) => {
-		const lower = candidate.toLowerCase();
-		return (
-			relativePath.toLowerCase() === lower || relativePath.toLowerCase().startsWith(`${lower}/`)
-		);
-	});
+	const entry = config.include.find((candidate) => pathMatchesInclude(relativePath, candidate));
 	if (!entry) return undefined;
 	const root = syncRootPath(entry);
 	const suffix = relativePath.slice(entry.length);

package/src/snapshot.ts

@@ -31,6 +31,31 @@ 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[] = [];

package/src/status.ts

@@ -49,6 +49,11 @@ export function deriveSyncStatus(
 	return { label: "up-to-date", ahead: 0, behind: 0, conflicts: 0 };
 }
 
+/** 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. */
 export function syncIndicatorText(info: SyncStatusInfo): string {
 	switch (info.label) {