@lisang233/pi-sync 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lisang233/pi-sync",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"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/operations.ts

@@ -76,7 +76,7 @@ async function computeState(config: SyncConfig, signal?: AbortSignal): Promise<S
 		readMergeBase(config, { signal }),
 		isMergeInProgress({ signal }),
 	]);
-	return classifyState(local, remote, base, mergePending);
+	return classifyState(local, remote, base, mergePending, config.include);
 }
 
 export async function status(

package/src/status.ts

@@ -1,3 +1,5 @@
+import { pathMatchesInclude } from "./tree.js";
+
 export type SyncStateLabel =
 	| "unconfigured"
 	| "unknown"
@@ -37,17 +39,29 @@ export interface StateClassify {
  * `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.
+ *
+ * `include` is the include declaration. The remote and base maps are projected
+ * onto the include scope before comparison, so out-of-include paths (for
+ * example legacy `pi-sync/home/...` remnants from the old single-snapshot
+ * architecture) never pollute the state. A path the local side does not contain
+ * is never treated as a local change, which fixes the false "ahead" when the
+ * remote carries leftover paths the local never synced.
  */
 export function classifyState(
 	local: Map<string, string>,
 	remote: Map<string, string>,
 	base: Map<string, string>,
 	mergePending: boolean,
+	include: string[],
 ): StateClassify {
+	const inInclude = (p: string) => include.some((entry) => pathMatchesInclude(p, entry));
+	const remoteP = new Map([...remote].filter(([p]) => inInclude(p)));
+	const baseP = new Map([...base].filter(([p]) => inInclude(p)));
+
 	if (mergePending) {
-		const diverged = [...new Set([...local.keys(), ...remote.keys()])].filter(
-			(p) => local.get(p) !== remote.get(p),
-		);
+		const diverged = [...new Set([...local.keys(), ...remoteP.keys()])]
+			.filter((p) => local.get(p) !== remoteP.get(p))
+			.filter(inInclude);
 		return {
 			label: "conflict",
 			ahead: 0,
@@ -58,24 +72,28 @@ export function classifyState(
 			diverged,
 		};
 	}
-	const paths = [...new Set([...local.keys(), ...remote.keys()])].sort();
+	const paths = [...new Set([...local.keys(), ...remoteP.keys()])].filter(inInclude).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);
+		const remoteContent = remoteP.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;
+		const baseContent = baseP.get(filePath);
+		const baseHas = baseContent !== undefined;
+		// A side is "changed" only if it actually holds the path and its content
+		// differs from the base (an added or deleted file counts). Without a base
+		// (fresh branch) fall back to "the side holds the path".
+		const localChangedSide = baseHas ? localContent !== baseContent : localContent !== undefined;
+		const remoteChangedSide = baseHas ? remoteContent !== baseContent : remoteContent !== undefined;
 		if (localChangedSide && remoteChangedSide) diverged.push(filePath);
 		else if (localChangedSide) localChanged.push(filePath);
 		else if (remoteChangedSide) remoteChanged.push(filePath);
 	}
 
 	let label: SyncStateLabel;
-	if (remote.size === 0) label = "unpublished";
+	if (remoteP.size === 0) label = "unpublished";
 	else if (diverged.length > 0 || (localChanged.length > 0 && remoteChanged.length > 0)) {
 		label = "conflict";
 	} else if (remoteChanged.length > 0) {