kintone-migrator 0.23.0 → 0.24.0

package/dist/index.mjs

@@ -321,6 +321,18 @@ function isSystemError(error) {
 	return error instanceof SystemError;
 }
 
+//#endregion
+//#region src/lib/typeGuards.ts
+/**
+* Narrows `unknown` to a plain `Record<string, unknown>`.
+* Returns true when the value is a non-null, non-array plain object.
+* Excludes built-in types (Date, RegExp, Map, Set) that are technically
+* objects but should not be treated as string-keyed records.
+*/
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set);
+}
+
 //#endregion
 //#region src/core/domain/typeGuards.ts
 /**
@@ -328,13 +340,6 @@ function isSystemError(error) {
 * Use these functions instead of `as` casts when working with `unknown` values.
 */
 /**
-* Narrows `unknown` to `Record<string, unknown>`.
-* Returns true when the value is a non-null object (and not an array).
-*/
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
 * Narrows `unknown` to `{ code: string }`.
 */
 function hasCode(value) {
@@ -1964,42 +1969,73 @@ function colorizeDiffEntry(type) {
 		prefix: type === "added" ? "+" : type === "deleted" ? "-" : "~"
 	};
 }
-function printDiffResult(result) {
+function printGenericDiffResult(result, title, formatEntry) {
+	for (const w of result.warnings) p.log.warn(w);
 	if (result.isEmpty) {
 		p.log.info("No changes detected.");
 		return;
 	}
 	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
-	if (result.hasLayoutChanges) p.log.info("Layout changes detected.");
 	const lines = result.entries.map((entry) => {
 		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]")} ${entry.fieldLabel}${pc.dim(":")} ${entry.details}`;
+		return formatEntry(entry, colorize, prefix);
 	});
-	p.note(lines.join("\n"), "Diff Details", { format: (v) => v });
+	p.note(lines.join("\n"), title, { format: (v) => v });
 }
-function printViewDiffResult(result) {
-	if (result.isEmpty) {
-		p.log.info("No changes detected.");
-		return;
-	}
-	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
-	const lines = result.entries.map((entry) => {
-		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${colorize(entry.viewName)}${pc.dim(":")} ${entry.details}`;
+function printActionDiffResult(result) {
+	printGenericDiffResult(result, "Action Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.actionName)}${pc.dim(":")} ${entry.details}`);
+}
+function printAdminNotesDiffResult(result) {
+	printFieldDiffResult(result, "Admin Notes Diff Details");
+}
+function printAppPermissionDiffResult(result) {
+	printGenericDiffResult(result, "App Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.entityKey)}${pc.dim(":")} ${entry.details}`);
+}
+function printCustomizationDiffResult(result) {
+	printGenericDiffResult(result, "Customization Diff Details", (entry, colorize, prefix) => {
+		const location = entry.platform === "config" ? entry.category : `${entry.platform}.${entry.category}`;
+		return `${colorize(prefix)} ${pc.dim("[")}${colorize(location)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`;
 	});
-	p.note(lines.join("\n"), "View Diff Details", { format: (v) => v });
 }
-function printProcessDiffResult(result) {
+function printDiffResult(result) {
 	if (result.isEmpty) {
 		p.log.info("No changes detected.");
 		return;
 	}
 	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
+	if (result.hasLayoutChanges) p.log.info("Layout changes detected.");
 	const lines = result.entries.map((entry) => {
 		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.category)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`;
+		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]")} ${entry.fieldLabel}${pc.dim(":")} ${entry.details}`;
 	});
-	p.note(lines.join("\n"), "Process Management Diff Details", { format: (v) => v });
+	p.note(lines.join("\n"), "Diff Details", { format: (v) => v });
+}
+function printFieldPermissionDiffResult(result) {
+	printGenericDiffResult(result, "Field Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]:")} ${entry.details}`);
+}
+function printGeneralSettingsDiffResult(result) {
+	printFieldDiffResult(result, "General Settings Diff Details");
+}
+function printNotificationDiffResult(result) {
+	printGenericDiffResult(result, "Notification Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.section)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`);
+}
+function printPluginDiffResult(result) {
+	printGenericDiffResult(result, "Plugin Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.pluginId)}${pc.dim(":")} ${entry.details}`);
+}
+function printProcessDiffResult(result) {
+	printGenericDiffResult(result, "Process Management Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.category)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`);
+}
+function printRecordPermissionDiffResult(result) {
+	printGenericDiffResult(result, "Record Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.filterCond === "" ? "(all records)" : entry.filterCond)}${pc.dim("]:")} ${entry.details}`);
+}
+function printReportDiffResult(result) {
+	printGenericDiffResult(result, "Report Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.reportName)}${pc.dim(":")} ${entry.details}`);
+}
+function printViewDiffResult(result) {
+	printGenericDiffResult(result, "View Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.viewName)}${pc.dim(":")} ${entry.details}`);
+}
+function printFieldDiffResult(result, title) {
+	printGenericDiffResult(result, title, (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.field)}${pc.dim(":")} ${entry.details}`);
 }
 function printAppHeader(appName, appId) {
 	p.log.step(`\n=== [${pc.bold(appName)}] (app: ${appId}) ===`);
@@ -2051,8 +2087,13 @@ async function promptDeploy(container, skipConfirm) {
 	}
 	const ds = p.spinner();
 	ds.start("Deploying to production...");
-	await deployApp({ container });
-	ds.stop("Deployment complete.");
+	try {
+		await deployApp({ container });
+		ds.stop("Deployment complete.");
+	} catch (error) {
+		ds.stop("Deployment failed.");
+		throw error;
+	}
 	p.log.success("Deployed to production.");
 }
 
@@ -2321,7 +2362,7 @@ function serializeMapping(mapping) {
 	if (mapping.srcField !== void 0) result.srcField = mapping.srcField;
 	return result;
 }
-function serializeEntity$1(entity) {
+function serializeEntity$2(entity) {
 	return {
 		type: entity.type,
 		code: entity.code
@@ -2332,7 +2373,7 @@ function serializeActionConfig(config) {
 		index: config.index,
 		destApp: serializeDestApp(config.destApp),
 		mappings: config.mappings.map(serializeMapping),
-		entities: config.entities.map(serializeEntity$1),
+		entities: config.entities.map(serializeEntity$2),
 		filterCond: config.filterCond
 	};
 }
@@ -2407,6 +2448,238 @@ var capture_default$13 = define({
 	}
 });
 
+//#endregion
+//#region src/lib/deepEqual.ts
+function isArrayEqual(a, b, seen) {
+	if (!Array.isArray(b)) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!deepEqualInner(a[i], b[i], seen)) return false;
+	return true;
+}
+function isRecordEqual(a, b, seen) {
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!deepEqualInner(a[key], b[key], seen)) return false;
+	}
+	return true;
+}
+function isMapEqual$1(a, b, seen) {
+	if (!(b instanceof Map)) return false;
+	if (a.size !== b.size) return false;
+	for (const [key, valA] of a) {
+		if (!b.has(key)) return false;
+		if (!deepEqualInner(valA, b.get(key), seen)) return false;
+	}
+	return true;
+}
+function isSetEqual(a, b, _seen) {
+	if (!(b instanceof Set)) return false;
+	if (a.size !== b.size) return false;
+	const remaining = [...b];
+	for (const valA of a) {
+		const idx = remaining.findIndex((valB) => deepEqualInner(valA, valB, /* @__PURE__ */ new WeakSet()));
+		if (idx === -1) return false;
+		remaining.splice(idx, 1);
+	}
+	return true;
+}
+function deepEqualInner(a, b, seen) {
+	if (a === b) return true;
+	if (a === null || b === null) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	const objA = a;
+	const objB = b;
+	if (seen.has(objA) || seen.has(objB)) return false;
+	seen.add(objA);
+	seen.add(objB);
+	if (Array.isArray(objA)) return isArrayEqual(objA, objB, seen);
+	if (objA instanceof Date && objB instanceof Date) return objA.getTime() === objB.getTime();
+	if (objA instanceof Date || objB instanceof Date) return false;
+	if (objA instanceof RegExp && objB instanceof RegExp) return String(objA) === String(objB);
+	if (objA instanceof RegExp || objB instanceof RegExp) return false;
+	if (objA instanceof Map) return isMapEqual$1(objA, objB, seen);
+	if (objB instanceof Map) return false;
+	if (objA instanceof Set) return isSetEqual(objA, objB, seen);
+	if (objB instanceof Set) return false;
+	if (isRecord$1(objA) && isRecord$1(objB)) return isRecordEqual(objA, objB, seen);
+	return false;
+}
+/**
+* Deep equality comparison for structured data.
+* Supports primitives, plain objects, arrays, Date, RegExp, Map, and Set.
+* Has circular reference protection via a WeakSet-based seen check (tracks both sides).
+*
+* Note: `{ a: undefined }` and `{}` are NOT considered equal. This differs from
+* JSON.stringify behavior but is intentional — explicit undefined properties are
+* semantically distinct from absent properties.
+*
+* Set comparison is order-independent: each element in one set is matched to an
+* element in the other using deep equality (O(n²)).
+*
+* NaN handling: `deepEqual(NaN, NaN)` returns `false` because the comparison
+* uses strict equality (`===`) for primitives, and `NaN !== NaN` in JavaScript.
+*
+* Circular reference limitation: objects already visited by the traversal are
+* treated as non-equal. This means structurally identical circular references
+* (e.g. `a.self = a` vs `b.self = b`) return `false`. This is a conservative
+* approach that prevents infinite recursion but may produce false negatives.
+*/
+function deepEqual$1(a, b) {
+	return deepEqualInner(a, b, /* @__PURE__ */ new WeakSet());
+}
+
+//#endregion
+//#region src/core/domain/diff.ts
+const typeOrder = {
+	added: 0,
+	modified: 1,
+	deleted: 2
+};
+function buildDiffResult(entries, warnings = []) {
+	const sorted = [...entries].sort((a, b) => typeOrder[a.type] - typeOrder[b.type]);
+	let added = 0;
+	let modified = 0;
+	let deleted = 0;
+	for (const e of sorted) if (e.type === "added") added++;
+	else if (e.type === "modified") modified++;
+	else deleted++;
+	return {
+		entries: sorted,
+		summary: {
+			added,
+			modified,
+			deleted,
+			total: sorted.length
+		},
+		isEmpty: sorted.length === 0,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/core/domain/action/services/diffDetector.ts
+function compareActions$1(local, remote) {
+	const diffs = [];
+	if (local.index !== remote.index) diffs.push(`index: ${remote.index} -> ${local.index}`);
+	if (local.name !== remote.name) diffs.push(`name: "${remote.name}" -> "${local.name}"`);
+	if (!deepEqual$1(local.destApp, remote.destApp)) diffs.push("destApp changed");
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual$1(local.mappings, remote.mappings)) if (local.mappings.length !== remote.mappings.length) diffs.push(`mappings: ${remote.mappings.length} -> ${local.mappings.length}`);
+	else diffs.push("mappings changed");
+	if (!deepEqual$1(local.entities, remote.entities)) diffs.push("entities changed");
+	return diffs;
+}
+const ActionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	for (const [name, localAction] of Object.entries(local.actions)) {
+		const remoteAction = remote.actions[name];
+		if (!remoteAction) entries.push({
+			type: "added",
+			actionName: name,
+			details: `dest: ${localAction.destApp.app ?? localAction.destApp.code ?? "(unspecified)"}`
+		});
+		else {
+			const diffs = compareActions$1(localAction, remoteAction);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				actionName: name,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [name, remoteAction] of Object.entries(remote.actions)) if (!local.actions[name]) entries.push({
+		type: "deleted",
+		actionName: name,
+		details: `dest: ${remoteAction.destApp.app ?? remoteAction.destApp.code ?? "(unspecified)"}`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/detectDiffBase.ts
+async function detectDiffFromConfig(config) {
+	const [storageResult, remote] = await Promise.all([config.getStorage(), config.fetchRemote()]);
+	if (!storageResult.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, config.notFoundMessage);
+	const local = config.parseConfig(storageResult.content);
+	return config.detect(local, remote);
+}
+
+//#endregion
+//#region src/core/application/action/detectActionDiff.ts
+async function detectActionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.actionStorage.get(),
+		fetchRemote: () => container.actionConfigurator.getActions(),
+		parseConfig: parseActionConfigText,
+		detect: (local, remote) => ActionDiffDetector.detect(local, { actions: remote.actions }),
+		notFoundMessage: "Action config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/diffCommandFactory.ts
+function createDiffCommand(config) {
+	async function runDiff(containerConfig) {
+		const container = config.createContainer(containerConfig);
+		const s = p.spinner();
+		s.start(config.spinnerMessage);
+		let result;
+		try {
+			result = await config.detectDiff({ container });
+		} catch (error) {
+			s.stop("Comparison failed.");
+			throw error;
+		}
+		s.stop("Comparison complete.");
+		config.printResult(result);
+	}
+	return define({
+		name: "diff",
+		description: config.description,
+		args: config.args,
+		run: async (ctx) => {
+			try {
+				const values = ctx.values;
+				await routeMultiApp(values, {
+					singleLegacy: async () => {
+						await runDiff(config.resolveContainerConfig(values));
+					},
+					singleApp: async (app, projectConfig) => {
+						await runDiff(config.resolveAppContainerConfig(app, projectConfig, values));
+					},
+					multiApp: async (plan, projectConfig) => {
+						await runMultiAppWithFailCheck(plan, async (app) => {
+							const containerConfig = config.resolveAppContainerConfig(app, projectConfig, values);
+							printAppHeader(app.name, app.appId);
+							await runDiff(containerConfig);
+						}, config.multiAppSuccessMessage);
+					}
+				});
+			} catch (error) {
+				handleCliError(error);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/commands/action/diff.ts
+var diff_default$12 = createDiffCommand({
+	description: "Compare local action config with remote kintone app",
+	args: actionArgs,
+	spinnerMessage: "Comparing action settings...",
+	multiAppSuccessMessage: "All action diffs completed successfully.",
+	createContainer: createActionCliContainer,
+	detectDiff: detectActionDiff,
+	printResult: printActionDiffResult,
+	resolveContainerConfig: resolveActionContainerConfig,
+	resolveAppContainerConfig: resolveActionAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/action/index.ts
 var action_default = define({
@@ -2414,7 +2687,8 @@ var action_default = define({
 	description: "Manage kintone action settings",
 	subCommands: {
 		apply: apply_default$12,
-		capture: capture_default$13
+		capture: capture_default$13,
+		diff: diff_default$12
 	},
 	run: () => {}
 });
@@ -2662,6 +2936,52 @@ var capture_default$12 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/adminNotes/services/diffDetector.ts
+function compareConfigs$2(local, remote) {
+	const entries = [];
+	if (local.content !== remote.content) entries.push({
+		type: "modified",
+		field: "content",
+		details: "content changed"
+	});
+	if (local.includeInTemplateAndDuplicates !== remote.includeInTemplateAndDuplicates) entries.push({
+		type: "modified",
+		field: "includeInTemplateAndDuplicates",
+		details: `${String(remote.includeInTemplateAndDuplicates)} -> ${String(local.includeInTemplateAndDuplicates)}`
+	});
+	return entries;
+}
+const AdminNotesDiffDetector = { detect: (local, remote) => {
+	return buildDiffResult(compareConfigs$2(local, remote));
+} };
+
+//#endregion
+//#region src/core/application/adminNotes/detectAdminNotesDiff.ts
+async function detectAdminNotesDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.adminNotesStorage.get(),
+		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
+		parseConfig: parseAdminNotesConfigText,
+		detect: (local, remote) => AdminNotesDiffDetector.detect(local, remote.config),
+		notFoundMessage: "Admin notes config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/admin-notes/diff.ts
+var diff_default$11 = createDiffCommand({
+	description: "Compare local admin notes config with remote kintone app",
+	args: adminNotesArgs,
+	spinnerMessage: "Comparing admin notes...",
+	multiAppSuccessMessage: "All admin notes diffs completed successfully.",
+	createContainer: createAdminNotesCliContainer,
+	detectDiff: detectAdminNotesDiff,
+	printResult: printAdminNotesDiffResult,
+	resolveContainerConfig: resolveAdminNotesContainerConfig,
+	resolveAppContainerConfig: resolveAdminNotesAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/admin-notes/index.ts
 var admin_notes_default = define({
@@ -2669,7 +2989,8 @@ var admin_notes_default = define({
 	description: "Manage kintone admin notes",
 	subCommands: {
 		apply: apply_default$11,
-		capture: capture_default$12
+		capture: capture_default$12,
+		diff: diff_default$11
 	},
 	run: () => {}
 });
@@ -3016,6 +3337,84 @@ var capture_default$11 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/appPermission/services/diffDetector.ts
+const BOOLEAN_FLAGS = [
+	"includeSubs",
+	"appEditable",
+	"recordViewable",
+	"recordAddable",
+	"recordEditable",
+	"recordDeletable",
+	"recordImportable",
+	"recordExportable"
+];
+function entityKey(right) {
+	return `${right.entity.type}:${right.entity.code}`;
+}
+function describeRight$1(right) {
+	const flags = BOOLEAN_FLAGS.filter((f) => f !== "includeSubs" && right[f]);
+	return flags.length > 0 ? flags.join(", ") : "no permissions";
+}
+function compareRights(local, remote) {
+	const diffs = [];
+	for (const flag of BOOLEAN_FLAGS) if (local[flag] !== remote[flag]) diffs.push(`${flag}: ${String(remote[flag])} -> ${String(local[flag])}`);
+	return diffs;
+}
+const AppPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.rights.map((r) => [entityKey(r), r]));
+	const remoteMap = new Map(remote.rights.map((r) => [entityKey(r), r]));
+	for (const [key, localRight] of localMap) {
+		const remoteRight = remoteMap.get(key);
+		if (!remoteRight) entries.push({
+			type: "added",
+			entityKey: key,
+			details: describeRight$1(localRight)
+		});
+		else {
+			const diffs = compareRights(localRight, remoteRight);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				entityKey: key,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [key, remoteRight] of remoteMap) if (!localMap.has(key)) entries.push({
+		type: "deleted",
+		entityKey: key,
+		details: describeRight$1(remoteRight)
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/appPermission/detectAppPermissionDiff.ts
+async function detectAppPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.appPermissionStorage.get(),
+		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
+		parseConfig: parseAppPermissionConfigText,
+		detect: (local, remote) => AppPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "App permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/app-acl/diff.ts
+var diff_default$10 = createDiffCommand({
+	description: "Compare local app permission config with remote kintone app",
+	args: appAclArgs,
+	spinnerMessage: "Comparing app permissions...",
+	multiAppSuccessMessage: "All app permission diffs completed successfully.",
+	createContainer: createAppPermissionCliContainer,
+	detectDiff: detectAppPermissionDiff,
+	printResult: printAppPermissionDiffResult,
+	resolveContainerConfig: resolveAppAclContainerConfig,
+	resolveAppContainerConfig: resolveAppAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/app-acl/index.ts
 var app_acl_default = define({
@@ -3023,7 +3422,8 @@ var app_acl_default = define({
 	description: "Manage kintone app access permissions",
 	subCommands: {
 		apply: apply_default$10,
-		capture: capture_default$11
+		capture: capture_default$11,
+		diff: diff_default$10
 	},
 	run: () => {}
 });
@@ -3499,6 +3899,105 @@ var apply_default$9 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/customization/valueObject.ts
+const DEFAULT_CUSTOMIZATION_SCOPE = "ALL";
+
+//#endregion
+//#region src/core/domain/customization/services/diffDetector.ts
+function resourceName(resource) {
+	if (resource.type === "URL") return resource.url;
+	const parts = resource.path.replace(/\\/g, "/").split("/");
+	return parts[parts.length - 1];
+}
+function remoteResourceName(resource) {
+	if (resource.type === "URL") return resource.url;
+	return resource.file.name;
+}
+function compareResourceLists(localResources, remoteResources, platform, resourceType, warnings) {
+	const entries = [];
+	const localNames = localResources.map(resourceName);
+	const remoteNames = remoteResources.map(remoteResourceName);
+	const localNameSet = new Set(localNames);
+	const remoteNameSet = new Set(remoteNames);
+	const hasDuplicates = localNames.length !== localNameSet.size || remoteNames.length !== remoteNameSet.size;
+	if (hasDuplicates) warnings.push(`[${platform}.${resourceType}] duplicate basenames detected; diff results may be inaccurate for FILE resources`);
+	for (const name of localNameSet) if (!remoteNameSet.has(name)) entries.push({
+		type: "added",
+		platform,
+		category: resourceType,
+		name,
+		details: "new resource"
+	});
+	for (const name of remoteNameSet) if (!localNameSet.has(name)) entries.push({
+		type: "deleted",
+		platform,
+		category: resourceType,
+		name,
+		details: "removed"
+	});
+	const matchedFiles = [...localNameSet].filter((n) => remoteNameSet.has(n));
+	const hasLocalFiles = localResources.some((r) => r.type === "FILE");
+	const hasRemoteFiles = remoteResources.some((r) => r.type === "FILE");
+	if (matchedFiles.length > 0 && hasLocalFiles && hasRemoteFiles) warnings.push(`[${platform}.${resourceType}] FILE resources are compared by name only; content changes are not detected`);
+	if (!hasDuplicates) {
+		const localShared = localNames.filter((n) => remoteNameSet.has(n));
+		const remoteShared = remoteNames.filter((n) => localNameSet.has(n));
+		if (localShared.length > 1 && localShared.length === remoteShared.length && localShared.some((n, i) => n !== remoteShared[i])) entries.push({
+			type: "modified",
+			platform,
+			category: resourceType,
+			name: "(order)",
+			details: "resource load order changed"
+		});
+	}
+	return entries;
+}
+function comparePlatform(localJs, localCss, remote, platform, warnings) {
+	return [...compareResourceLists(localJs, remote.js, platform, "js", warnings), ...compareResourceLists(localCss, remote.css, platform, "css", warnings)];
+}
+const CustomizationDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const warnings = [];
+	const localScope = local.scope ?? DEFAULT_CUSTOMIZATION_SCOPE;
+	if (localScope !== remote.scope) entries.push({
+		type: "modified",
+		platform: "config",
+		category: "scope",
+		name: "scope",
+		details: `${remote.scope} -> ${localScope}`
+	});
+	entries.push(...comparePlatform(local.desktop.js, local.desktop.css, remote.desktop, "desktop", warnings));
+	entries.push(...comparePlatform(local.mobile.js, local.mobile.css, remote.mobile, "mobile", warnings));
+	return buildDiffResult(entries, warnings);
+} };
+
+//#endregion
+//#region src/core/application/customization/detectCustomizationDiff.ts
+async function detectCustomizationDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.customizationStorage.get(),
+		fetchRemote: () => container.customizationConfigurator.getCustomization(),
+		parseConfig: (content) => parseConfigText(content),
+		detect: (local, remote) => CustomizationDiffDetector.detect(local, remote),
+		notFoundMessage: "Customization config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/customize/diff.ts
+var diff_default$9 = createDiffCommand({
+	description: "Compare local customization config with remote kintone app",
+	args: customizeArgs,
+	spinnerMessage: "Comparing customization settings...",
+	multiAppSuccessMessage: "All customization diffs completed successfully.",
+	createContainer: createCustomizationCliContainer,
+	detectDiff: detectCustomizationDiff,
+	printResult: printCustomizationDiffResult,
+	resolveContainerConfig: resolveCustomizeConfig,
+	resolveAppContainerConfig: resolveCustomizeAppConfig
+});
+
 //#endregion
 //#region src/cli/commands/customize/index.ts
 var customize_default = define({
@@ -3506,7 +4005,8 @@ var customize_default = define({
 	description: "Manage kintone JS/CSS customizations",
 	subCommands: {
 		apply: apply_default$9,
-		capture: capture_default$10
+		capture: capture_default$10,
+		diff: diff_default$9
 	},
 	run: () => {}
 });
@@ -3860,6 +4360,72 @@ var capture_default$9 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/fieldPermission/services/diffDetector.ts
+function areEntitiesEqual(a, b) {
+	return deepEqual$1(a.entities.map((e) => ({
+		accessibility: e.accessibility,
+		type: e.entity.type,
+		code: e.entity.code,
+		includeSubs: e.includeSubs ?? false
+	})), b.entities.map((e) => ({
+		accessibility: e.accessibility,
+		type: e.entity.type,
+		code: e.entity.code,
+		includeSubs: e.includeSubs ?? false
+	})));
+}
+const FieldPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.rights.map((r) => [r.code, r]));
+	const remoteMap = new Map(remote.rights.map((r) => [r.code, r]));
+	for (const [code, localRight] of localMap) {
+		const remoteRight = remoteMap.get(code);
+		if (!remoteRight) entries.push({
+			type: "added",
+			fieldCode: code,
+			details: `${localRight.entities.length} entities`
+		});
+		else if (!areEntitiesEqual(localRight, remoteRight)) entries.push({
+			type: "modified",
+			fieldCode: code,
+			details: "entities changed"
+		});
+	}
+	for (const code of remoteMap.keys()) if (!localMap.has(code)) entries.push({
+		type: "deleted",
+		fieldCode: code,
+		details: "removed"
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/fieldPermission/detectFieldPermissionDiff.ts
+async function detectFieldPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.fieldPermissionStorage.get(),
+		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
+		parseConfig: parseFieldPermissionConfigText,
+		detect: (local, remote) => FieldPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "Field permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/field-acl/diff.ts
+var diff_default$8 = createDiffCommand({
+	description: "Compare local field permission config with remote kintone app",
+	args: fieldAclArgs,
+	spinnerMessage: "Comparing field permissions...",
+	multiAppSuccessMessage: "All field permission diffs completed successfully.",
+	createContainer: createFieldPermissionCliContainer,
+	detectDiff: detectFieldPermissionDiff,
+	printResult: printFieldPermissionDiffResult,
+	resolveContainerConfig: resolveFieldAclContainerConfig,
+	resolveAppContainerConfig: resolveFieldAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/field-acl/index.ts
 var field_acl_default = define({
@@ -3867,7 +4433,8 @@ var field_acl_default = define({
 	description: "Manage kintone field access permissions",
 	subCommands: {
 		apply: apply_default$8,
-		capture: capture_default$9
+		capture: capture_default$9,
+		diff: diff_default$8
 	},
 	run: () => {}
 });
@@ -5322,7 +5889,7 @@ async function saveGeneralSettings({ container, input }) {
 
 //#endregion
 //#region src/core/domain/notification/services/configSerializer.ts
-function serializeEntity(entity) {
+function serializeEntity$1(entity) {
 	return {
 		type: entity.type,
 		code: entity.code
@@ -5330,7 +5897,7 @@ function serializeEntity(entity) {
 }
 function serializeGeneralNotification(notification) {
 	const result = {
-		entity: serializeEntity(notification.entity),
+		entity: serializeEntity$1(notification.entity),
 		recordAdded: notification.recordAdded,
 		recordEdited: notification.recordEdited,
 		commentAdded: notification.commentAdded,
@@ -5341,7 +5908,7 @@ function serializeGeneralNotification(notification) {
 	return result;
 }
 function serializePerRecordTarget(target) {
-	const result = { entity: serializeEntity(target.entity) };
+	const result = { entity: serializeEntity$1(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
 }
@@ -5353,7 +5920,7 @@ function serializePerRecordNotification(notification) {
 	};
 }
 function serializeReminderTarget(target) {
-	const result = { entity: serializeEntity(target.entity) };
+	const result = { entity: serializeEntity$1(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
 }
@@ -6328,26 +6895,273 @@ var capture_default$8 = define({
 });
 
 //#endregion
-//#region src/cli/commands/notification/index.ts
-var notification_default = define({
-	name: "notification",
-	description: "Manage kintone notification settings",
-	subCommands: {
-		apply: apply_default$7,
-		capture: capture_default$8
-	},
-	run: () => {}
-});
+//#region src/lib/groupByKey.ts
+/**
+* Groups items by a key function into a Map where each key maps to an array of items.
+* Multiple items can share the same key, producing a multimap structure.
+*/
+function groupByKey(items, keyFn) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyFn(item);
+		const existing = map.get(key);
+		if (existing) existing.push(item);
+		else map.set(key, [item]);
+	}
+	return map;
+}
 
 //#endregion
-//#region src/core/domain/plugin/services/configParser.ts
-function parsePluginEntry(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.id !== "string" || obj.id.length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyPluginId, `Plugin at index ${index} must have a non-empty "id" property`);
-	return {
-		id: obj.id,
-		name: typeof obj.name === "string" ? obj.name : "",
+//#region src/core/domain/notification/services/diffDetector.ts
+function serializeEntity(entity) {
+	return `${entity.type}:${entity.code}`;
+}
+const GENERAL_BOOLEAN_FLAGS = [
+	"recordAdded",
+	"recordEdited",
+	"commentAdded",
+	"statusChanged",
+	"fileImported"
+];
+function compareGeneralNotification(local, remote) {
+	const diffs = [];
+	if ((local.includeSubs ?? false) !== (remote.includeSubs ?? false)) diffs.push(`includeSubs: ${String(remote.includeSubs ?? false)} -> ${String(local.includeSubs ?? false)}`);
+	for (const flag of GENERAL_BOOLEAN_FLAGS) if (local[flag] !== remote[flag]) diffs.push(`${flag}: ${String(remote[flag])} -> ${String(local[flag])}`);
+	return diffs;
+}
+function compareGeneralSection(local, remote) {
+	const entries = [];
+	if (local.notifyToCommenter !== remote.notifyToCommenter) entries.push({
+		type: "modified",
+		section: "general",
+		name: "notifyToCommenter",
+		details: `${String(remote.notifyToCommenter)} -> ${String(local.notifyToCommenter)}`
+	});
+	const localMap = new Map(local.notifications.map((n) => [serializeEntity(n.entity), n]));
+	const remoteMap = new Map(remote.notifications.map((n) => [serializeEntity(n.entity), n]));
+	for (const [key, localNotif] of localMap) {
+		const remoteNotif = remoteMap.get(key);
+		if (!remoteNotif) entries.push({
+			type: "added",
+			section: "general",
+			name: key,
+			details: "new notification"
+		});
+		else {
+			const diffs = compareGeneralNotification(localNotif, remoteNotif);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				section: "general",
+				name: key,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const key of remoteMap.keys()) if (!localMap.has(key)) entries.push({
+		type: "deleted",
+		section: "general",
+		name: key,
+		details: "removed"
+	});
+	return entries;
+}
+/**
+* Groups per-record notifications by filterCond. Multiple notifications can share
+* the same filterCond, so notifications within a group are compared by position
+* (index-based matching).
+*/
+function buildPerRecordMultiMap(notifications) {
+	return groupByKey(notifications, (n) => n.filterCond);
+}
+function perRecordLabel(notif) {
+	return notif.title || notif.filterCond || "(empty filter)";
+}
+function describePerRecordChanges(local, remote) {
+	const diffs = [];
+	if (local.title !== remote.title) diffs.push("title changed");
+	if (!deepEqual$1(local.targets, remote.targets)) diffs.push("targets changed");
+	return diffs.length > 0 ? diffs.join(", ") : "changed";
+}
+function describeReminderChanges(local, remote) {
+	const diffs = [];
+	if (local.title !== remote.title) diffs.push("title changed");
+	if (local.daysLater !== remote.daysLater) diffs.push("daysLater changed");
+	if ((local.hoursLater ?? 0) !== (remote.hoursLater ?? 0)) diffs.push("hoursLater changed");
+	if ((local.time ?? "") !== (remote.time ?? "")) diffs.push("time changed");
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual$1(local.targets, remote.targets)) diffs.push("targets changed");
+	return diffs.length > 0 ? diffs.join(", ") : "changed";
+}
+function comparePerRecordSection(local, remote) {
+	const entries = [];
+	const localMulti = buildPerRecordMultiMap(local);
+	const remoteMulti = buildPerRecordMultiMap(remote);
+	for (const [key, localNotifs] of localMulti) {
+		const remoteNotifs = remoteMulti.get(key) ?? [];
+		const maxLen = Math.max(localNotifs.length, remoteNotifs.length);
+		for (let i = 0; i < maxLen; i++) {
+			const localNotif = localNotifs[i];
+			const remoteNotif = remoteNotifs[i];
+			if (localNotif && !remoteNotif) entries.push({
+				type: "added",
+				section: "perRecord",
+				name: perRecordLabel(localNotif),
+				details: "new notification"
+			});
+			else if (!localNotif && remoteNotif) entries.push({
+				type: "deleted",
+				section: "perRecord",
+				name: perRecordLabel(remoteNotif),
+				details: "removed"
+			});
+			else if (localNotif && remoteNotif && !deepEqual$1(localNotif, remoteNotif)) {
+				const diffs = describePerRecordChanges(localNotif, remoteNotif);
+				entries.push({
+					type: "modified",
+					section: "perRecord",
+					name: perRecordLabel(localNotif),
+					details: diffs
+				});
+			}
+		}
+	}
+	for (const [key, remoteNotifs] of remoteMulti) if (!localMulti.has(key)) for (const remoteNotif of remoteNotifs) entries.push({
+		type: "deleted",
+		section: "perRecord",
+		name: perRecordLabel(remoteNotif),
+		details: "removed"
+	});
+	return entries;
+}
+function compareReminderSection(local, remote) {
+	const entries = [];
+	const localMap = new Map(local.map((n) => [n.code, n]));
+	const remoteMap = new Map(remote.map((n) => [n.code, n]));
+	for (const [code, localNotif] of localMap) {
+		const remoteNotif = remoteMap.get(code);
+		if (!remoteNotif) entries.push({
+			type: "added",
+			section: "reminder",
+			name: code,
+			details: `"${localNotif.title}"`
+		});
+		else if (!deepEqual$1(localNotif, remoteNotif)) entries.push({
+			type: "modified",
+			section: "reminder",
+			name: code,
+			details: describeReminderChanges(localNotif, remoteNotif)
+		});
+	}
+	for (const code of remoteMap.keys()) if (!localMap.has(code)) entries.push({
+		type: "deleted",
+		section: "reminder",
+		name: code,
+		details: "removed"
+	});
+	return entries;
+}
+const NotificationDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	if (local.general && remote.general) entries.push(...compareGeneralSection(local.general, remote.general));
+	else if (local.general && !remote.general) entries.push({
+		type: "added",
+		section: "general",
+		name: "general",
+		details: "added general notifications section"
+	});
+	else if (!local.general && remote.general) entries.push({
+		type: "deleted",
+		section: "general",
+		name: "general",
+		details: "removed general notifications section"
+	});
+	const localPerRecord = local.perRecord ?? [];
+	const remotePerRecord = remote.perRecord ?? [];
+	entries.push(...comparePerRecordSection(localPerRecord, remotePerRecord));
+	if (local.reminder && remote.reminder) {
+		entries.push(...compareReminderSection(local.reminder.notifications, remote.reminder.notifications));
+		if (local.reminder.timezone !== remote.reminder.timezone) entries.push({
+			type: "modified",
+			section: "reminder",
+			name: "timezone",
+			details: `${remote.reminder.timezone} -> ${local.reminder.timezone}`
+		});
+	} else if (local.reminder && !remote.reminder) entries.push({
+		type: "added",
+		section: "reminder",
+		name: "reminder",
+		details: "added reminder notifications section"
+	});
+	else if (!local.reminder && remote.reminder) entries.push({
+		type: "deleted",
+		section: "reminder",
+		name: "reminder",
+		details: "removed reminder notifications section"
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/notification/detectNotificationDiff.ts
+async function detectNotificationDiff({ container }) {
+	const [storageResult, generalResult, perRecordResult, reminderResult] = await Promise.all([
+		container.notificationStorage.get(),
+		container.notificationConfigurator.getGeneralNotifications(),
+		container.notificationConfigurator.getPerRecordNotifications(),
+		container.notificationConfigurator.getReminderNotifications()
+	]);
+	if (!storageResult.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Notification config file not found");
+	const localConfig = parseNotificationConfigText(storageResult.content);
+	const remoteConfig = {
+		general: {
+			notifyToCommenter: generalResult.notifyToCommenter,
+			notifications: generalResult.notifications
+		},
+		perRecord: perRecordResult.notifications,
+		reminder: {
+			timezone: reminderResult.timezone,
+			notifications: reminderResult.notifications
+		}
+	};
+	return NotificationDiffDetector.detect(localConfig, remoteConfig);
+}
+
+//#endregion
+//#region src/cli/commands/notification/diff.ts
+var diff_default$7 = createDiffCommand({
+	description: "Compare local notification config with remote kintone app",
+	args: notificationArgs,
+	spinnerMessage: "Comparing notification settings...",
+	multiAppSuccessMessage: "All notification diffs completed successfully.",
+	createContainer: createNotificationCliContainer,
+	detectDiff: detectNotificationDiff,
+	printResult: printNotificationDiffResult,
+	resolveContainerConfig: resolveNotificationContainerConfig,
+	resolveAppContainerConfig: resolveNotificationAppContainerConfig
+});
+
+//#endregion
+//#region src/cli/commands/notification/index.ts
+var notification_default = define({
+	name: "notification",
+	description: "Manage kintone notification settings",
+	subCommands: {
+		apply: apply_default$7,
+		capture: capture_default$8,
+		diff: diff_default$7
+	},
+	run: () => {}
+});
+
+//#endregion
+//#region src/core/domain/plugin/services/configParser.ts
+function parsePluginEntry(raw, index) {
+	if (!isRecord$1(raw)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} must be an object`);
+	const obj = raw;
+	if (typeof obj.id !== "string" || obj.id.length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyPluginId, `Plugin at index ${index} must have a non-empty "id" property`);
+	return {
+		id: obj.id,
+		name: typeof obj.name === "string" ? obj.name : "",
 		enabled: typeof obj.enabled === "boolean" ? obj.enabled : true
 	};
 }
@@ -6497,6 +7311,64 @@ var capture_default$7 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/plugin/services/diffDetector.ts
+const PluginDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.plugins.map((p) => [p.id, p]));
+	const remoteMap = new Map(remote.plugins.map((p) => [p.id, p]));
+	for (const [id, localPlugin] of localMap) {
+		const remotePlugin = remoteMap.get(id);
+		if (!remotePlugin) entries.push({
+			type: "added",
+			pluginId: id,
+			details: `"${localPlugin.name}"`
+		});
+		else {
+			const diffs = [];
+			if (localPlugin.name !== remotePlugin.name) diffs.push(`name: "${remotePlugin.name}" -> "${localPlugin.name}"`);
+			if (localPlugin.enabled !== remotePlugin.enabled) diffs.push(`enabled: ${String(remotePlugin.enabled)} -> ${String(localPlugin.enabled)}`);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				pluginId: id,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [id, remotePlugin] of remoteMap) if (!localMap.has(id)) entries.push({
+		type: "deleted",
+		pluginId: id,
+		details: `"${remotePlugin.name}"`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/plugin/detectPluginDiff.ts
+async function detectPluginDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.pluginStorage.get(),
+		fetchRemote: () => container.pluginConfigurator.getPlugins(),
+		parseConfig: parsePluginConfigText,
+		detect: (local, remote) => PluginDiffDetector.detect(local, { plugins: remote.plugins }),
+		notFoundMessage: "Plugin config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/plugin/diff.ts
+var diff_default$6 = createDiffCommand({
+	description: "Compare local plugin config with remote kintone app",
+	args: pluginArgs,
+	spinnerMessage: "Comparing plugin settings...",
+	multiAppSuccessMessage: "All plugin diffs completed successfully.",
+	createContainer: createPluginCliContainer,
+	detectDiff: detectPluginDiff,
+	printResult: printPluginDiffResult,
+	resolveContainerConfig: resolvePluginContainerConfig,
+	resolveAppContainerConfig: resolvePluginAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/plugin/index.ts
 var plugin_default = define({
@@ -6504,7 +7376,8 @@ var plugin_default = define({
 	description: "Manage kintone plugins",
 	subCommands: {
 		apply: apply_default$6,
-		capture: capture_default$7
+		capture: capture_default$7,
+		diff: diff_default$6
 	},
 	run: () => {}
 });
@@ -6781,7 +7654,7 @@ function compareActions(localAction, remoteAction) {
 	if (!isExecutableUserEqual(localAction.executableUser, remoteAction.executableUser)) diffs.push("executableUser changed");
 	return diffs;
 }
-function compareConfigs(local, remote) {
+function compareConfigs$1(local, remote) {
 	const entries = [];
 	if (local.enable !== remote.enable) entries.push({
 		type: "modified",
@@ -6846,68 +7719,33 @@ function compareConfigs(local, remote) {
 	return entries;
 }
 const ProcessManagementDiffDetector = { detect: (local, remote) => {
-	const entries = compareConfigs(local, remote);
-	const added = entries.filter((e) => e.type === "added").length;
-	const modified = entries.filter((e) => e.type === "modified").length;
-	const deleted = entries.filter((e) => e.type === "deleted").length;
-	return {
-		entries,
-		summary: {
-			added,
-			modified,
-			deleted,
-			total: added + modified + deleted
-		},
-		isEmpty: entries.length === 0
-	};
+	return buildDiffResult(compareConfigs$1(local, remote));
 } };
 
 //#endregion
 //#region src/core/application/processManagement/detectProcessManagementDiff.ts
 async function detectProcessManagementDiff({ container }) {
-	const result = await container.processManagementStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Process management config file not found");
-	const localConfig = parseProcessManagementConfigText(result.content);
-	const { config: remoteConfig } = await container.processManagementConfigurator.getProcessManagement();
-	return ProcessManagementDiffDetector.detect(localConfig, remoteConfig);
+	return detectDiffFromConfig({
+		getStorage: () => container.processManagementStorage.get(),
+		fetchRemote: () => container.processManagementConfigurator.getProcessManagement(),
+		parseConfig: parseProcessManagementConfigText,
+		detect: (local, remote) => ProcessManagementDiffDetector.detect(local, remote.config),
+		notFoundMessage: "Process management config file not found"
+	});
 }
 
 //#endregion
 //#region src/cli/commands/process/diff.ts
-async function runDiffProcess(config) {
-	const container = createProcessManagementCliContainer(config);
-	const s = p.spinner();
-	s.start("Comparing process management settings...");
-	const result = await detectProcessManagementDiff({ container });
-	s.stop("Comparison complete.");
-	printProcessDiffResult(result);
-}
-var diff_default$2 = define({
-	name: "diff",
+var diff_default$5 = createDiffCommand({
 	description: "Compare local process management settings with remote kintone app",
 	args: processArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runDiffProcess(resolveProcessContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runDiffProcess(resolveProcessAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveProcessAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runDiffProcess(config);
-					}, "All process management diffs completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Comparing process management settings...",
+	multiAppSuccessMessage: "All process management diffs completed successfully.",
+	createContainer: createProcessManagementCliContainer,
+	detectDiff: detectProcessManagementDiff,
+	printResult: printProcessDiffResult,
+	resolveContainerConfig: resolveProcessContainerConfig,
+	resolveAppContainerConfig: resolveProcessAppContainerConfig
 });
 
 //#endregion
@@ -6918,7 +7756,7 @@ var process_default = define({
 	subCommands: {
 		apply: apply_default$5,
 		capture: capture_default$6,
-		diff: diff_default$2
+		diff: diff_default$5
 	},
 	run: () => {}
 });
@@ -7113,6 +7951,104 @@ var capture_default$5 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/recordPermission/services/diffDetector.ts
+function areRightsEqual(a, b) {
+	return deepEqual$1(a.entities.map((e) => ({
+		type: e.entity.type,
+		code: e.entity.code,
+		viewable: e.viewable,
+		editable: e.editable,
+		deletable: e.deletable,
+		includeSubs: e.includeSubs
+	})), b.entities.map((e) => ({
+		type: e.entity.type,
+		code: e.entity.code,
+		viewable: e.viewable,
+		editable: e.editable,
+		deletable: e.deletable,
+		includeSubs: e.includeSubs
+	})));
+}
+function describeRight(right) {
+	const perEntity = right.entities.map((e) => {
+		const perms = [
+			e.viewable ? "view" : null,
+			e.editable ? "edit" : null,
+			e.deletable ? "delete" : null
+		].filter(Boolean).join("/");
+		return `${e.entity.type}:${e.entity.code}(${perms || "none"})`;
+	});
+	return perEntity.length > 0 ? perEntity.join(", ") : "no entities";
+}
+const RecordPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMulti = groupByKey(local.rights, (r) => r.filterCond);
+	const remoteMulti = groupByKey(remote.rights, (r) => r.filterCond);
+	for (const [filterCond, localRights] of localMulti) {
+		const remoteRights = remoteMulti.get(filterCond) ?? [];
+		const maxLen = Math.max(localRights.length, remoteRights.length);
+		for (let i = 0; i < maxLen; i++) {
+			const localRight = localRights[i];
+			const remoteRight = remoteRights[i];
+			if (localRight && !remoteRight) entries.push({
+				type: "added",
+				filterCond,
+				details: describeRight(localRight)
+			});
+			else if (!localRight && remoteRight) entries.push({
+				type: "deleted",
+				filterCond,
+				details: describeRight(remoteRight)
+			});
+			else if (localRight && remoteRight) {
+				if (!areRightsEqual(localRight, remoteRight)) {
+					const diffs = [];
+					if (localRight.entities.length !== remoteRight.entities.length) diffs.push(`entities: ${remoteRight.entities.length} -> ${localRight.entities.length}`);
+					else diffs.push("entities changed");
+					entries.push({
+						type: "modified",
+						filterCond,
+						details: diffs.join(", ")
+					});
+				}
+			}
+		}
+	}
+	for (const [filterCond, remoteRights] of remoteMulti) if (!localMulti.has(filterCond)) for (const remoteRight of remoteRights) entries.push({
+		type: "deleted",
+		filterCond,
+		details: describeRight(remoteRight)
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/recordPermission/detectRecordPermissionDiff.ts
+async function detectRecordPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.recordPermissionStorage.get(),
+		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
+		parseConfig: parseRecordPermissionConfigText,
+		detect: (local, remote) => RecordPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "Record permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/record-acl/diff.ts
+var diff_default$4 = createDiffCommand({
+	description: "Compare local record permission config with remote kintone app",
+	args: recordAclArgs,
+	spinnerMessage: "Comparing record permissions...",
+	multiAppSuccessMessage: "All record permission diffs completed successfully.",
+	createContainer: createRecordPermissionCliContainer,
+	detectDiff: detectRecordPermissionDiff,
+	printResult: printRecordPermissionDiffResult,
+	resolveContainerConfig: resolveRecordAclContainerConfig,
+	resolveAppContainerConfig: resolveRecordAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/record-acl/index.ts
 var record_acl_default = define({
@@ -7120,7 +8056,8 @@ var record_acl_default = define({
 	description: "Manage kintone record access permissions",
 	subCommands: {
 		apply: apply_default$4,
-		capture: capture_default$5
+		capture: capture_default$5,
+		diff: diff_default$4
 	},
 	run: () => {}
 });
@@ -7462,6 +8399,73 @@ var capture_default$4 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/report/services/diffDetector.ts
+function compareReports(local, remote) {
+	const diffs = [];
+	if (local.name !== remote.name) diffs.push(`name: "${remote.name}" -> "${local.name}"`);
+	if (local.chartType !== remote.chartType) diffs.push(`chartType: ${remote.chartType} -> ${local.chartType}`);
+	if ((local.chartMode ?? "") !== (remote.chartMode ?? "")) diffs.push(`chartMode: ${remote.chartMode ?? "(unset)"} -> ${local.chartMode ?? "(unset)"}`);
+	if (local.index !== remote.index) diffs.push(`index: ${remote.index} -> ${local.index}`);
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual$1(local.groups, remote.groups)) diffs.push("groups changed");
+	if (!deepEqual$1(local.aggregations, remote.aggregations)) diffs.push("aggregations changed");
+	if (!deepEqual$1(local.sorts, remote.sorts)) diffs.push("sorts changed");
+	if (!deepEqual$1(local.periodicReport ?? null, remote.periodicReport ?? null)) diffs.push("periodicReport changed");
+	return diffs;
+}
+const ReportDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	for (const [name, localReport] of Object.entries(local.reports)) {
+		const remoteReport = remote.reports[name];
+		if (!remoteReport) entries.push({
+			type: "added",
+			reportName: name,
+			details: `chartType: ${localReport.chartType}`
+		});
+		else {
+			const diffs = compareReports(localReport, remoteReport);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				reportName: name,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [name, remoteReport] of Object.entries(remote.reports)) if (!local.reports[name]) entries.push({
+		type: "deleted",
+		reportName: name,
+		details: `chartType: ${remoteReport.chartType}`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/report/detectReportDiff.ts
+async function detectReportDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.reportStorage.get(),
+		fetchRemote: () => container.reportConfigurator.getReports(),
+		parseConfig: parseReportConfigText,
+		detect: (local, remote) => ReportDiffDetector.detect(local, { reports: remote.reports }),
+		notFoundMessage: "Report config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/report/diff.ts
+var diff_default$3 = createDiffCommand({
+	description: "Compare local report config with remote kintone app",
+	args: reportArgs,
+	spinnerMessage: "Comparing report settings...",
+	multiAppSuccessMessage: "All report diffs completed successfully.",
+	createContainer: createReportCliContainer,
+	detectDiff: detectReportDiff,
+	printResult: printReportDiffResult,
+	resolveContainerConfig: resolveReportContainerConfig,
+	resolveAppContainerConfig: resolveReportAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/report/index.ts
 var report_default = define({
@@ -7469,7 +8473,8 @@ var report_default = define({
 	description: "Manage kintone report settings",
 	subCommands: {
 		apply: apply_default$3,
-		capture: capture_default$4
+		capture: capture_default$4,
+		diff: diff_default$3
 	},
 	run: () => {}
 });
@@ -7521,53 +8526,8 @@ var capture_default$3 = define({
 	}
 });
 
-//#endregion
-//#region src/core/domain/formSchema/entity.ts
-const FormDiff = { create: (entries) => {
-	const summary = {
-		added: entries.filter((e) => e.type === "added").length,
-		modified: entries.filter((e) => e.type === "modified").length,
-		deleted: entries.filter((e) => e.type === "deleted").length,
-		total: entries.length
-	};
-	const sortOrder = {
-		added: 0,
-		modified: 1,
-		deleted: 2
-	};
-	return {
-		entries: [...entries].sort((a, b) => sortOrder[a.type] - sortOrder[b.type]),
-		summary,
-		isEmpty: entries.length === 0
-	};
-} };
-
 //#endregion
 //#region src/core/domain/formSchema/services/diffDetector.ts
-function isArrayEqual$1(a, b) {
-	if (!Array.isArray(a) || !Array.isArray(b)) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (!isValueEqual(a[i], b[i])) return false;
-	return true;
-}
-function isRecordEqual(a, b) {
-	const keysA = Object.keys(a);
-	const keysB = Object.keys(b);
-	if (keysA.length !== keysB.length) return false;
-	for (const key of keysA) {
-		if (!Object.hasOwn(b, key)) return false;
-		if (!isValueEqual(a[key], b[key])) return false;
-	}
-	return true;
-}
-function isValueEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null) return a === b;
-	if (typeof a !== typeof b) return false;
-	if (Array.isArray(a)) return isArrayEqual$1(a, b);
-	if (isRecord$1(a) && isRecord$1(b)) return isRecordEqual(a, b);
-	return false;
-}
 function isMapEqual(a, b) {
 	if (a.size !== b.size) return false;
 	for (const [key, valA] of a) {
@@ -7579,18 +8539,8 @@ function isMapEqual(a, b) {
 }
 function isPropertiesEqual(a, b) {
 	if (a.type === "SUBTABLE" && b.type === "SUBTABLE") return isMapEqual(a.properties.fields, b.properties.fields);
-	if (a.type === "REFERENCE_TABLE" && b.type === "REFERENCE_TABLE") {
-		const refA = a.properties.referenceTable;
-		const refB = b.properties.referenceTable;
-		return isValueEqual({
-			...refA,
-			displayFields: [...refA.displayFields]
-		}, {
-			...refB,
-			displayFields: [...refB.displayFields]
-		});
-	}
-	return isValueEqual(a.properties, b.properties);
+	if (a.type === "REFERENCE_TABLE" && b.type === "REFERENCE_TABLE") return deepEqual$1(a.properties.referenceTable, b.properties.referenceTable);
+	return deepEqual$1(a.properties, b.properties);
 }
 function isFieldEqual(a, b) {
 	if (a.type !== b.type) return false;
@@ -7599,31 +8549,16 @@ function isFieldEqual(a, b) {
 	if (Boolean(a.noLabel) !== Boolean(b.noLabel)) return false;
 	return isPropertiesEqual(a, b);
 }
-function hasPropertiesChanged(before, after) {
-	if (before.type === "SUBTABLE" && after.type === "SUBTABLE") return !isMapEqual(before.properties.fields, after.properties.fields);
-	if (before.type === "REFERENCE_TABLE" && after.type === "REFERENCE_TABLE") {
-		const refB = before.properties.referenceTable;
-		const refA = after.properties.referenceTable;
-		return !isValueEqual({
-			...refB,
-			displayFields: [...refB.displayFields]
-		}, {
-			...refA,
-			displayFields: [...refA.displayFields]
-		});
-	}
-	return !isValueEqual(before.properties, after.properties);
-}
 function describeChanges$1(before, after) {
 	const changes = [];
 	if (before.type !== after.type) changes.push(`type: ${before.type} -> ${after.type}`);
 	if (before.label !== after.label) changes.push(`label: ${before.label} -> ${after.label}`);
 	if (Boolean(before.noLabel) !== Boolean(after.noLabel)) changes.push(`noLabel: ${before.noLabel ?? false} -> ${after.noLabel ?? false}`);
-	if (hasPropertiesChanged(before, after)) changes.push("properties changed");
+	if (!isPropertiesEqual(before, after)) changes.push("properties changed");
 	return changes.length > 0 ? changes.join(", ") : "no visible changes";
 }
 function isLayoutEqual(a, b) {
-	return isValueEqual(a, b);
+	return deepEqual$1(a, b);
 }
 const DiffDetector = {
 	detectLayoutChanges: (schemaLayout, currentLayout) => {
@@ -7653,10 +8588,10 @@ const DiffDetector = {
 			type: "deleted",
 			fieldCode,
 			fieldLabel: currentDef.label,
-			details: "deleted",
+			details: "removed",
 			before: currentDef
 		});
-		return FormDiff.create(entries);
+		return buildDiffResult(entries);
 	}
 };
 
@@ -8153,14 +9088,20 @@ async function detectDiff({ container }) {
 
 //#endregion
 //#region src/cli/commands/schema/diff.ts
-async function runDiff$1(container) {
+async function runDiff(container) {
 	const s = p.spinner();
 	s.start("Fetching form schema...");
-	const result = await detectDiff({ container });
+	let result;
+	try {
+		result = await detectDiff({ container });
+	} catch (error) {
+		s.stop("Comparison failed.");
+		throw error;
+	}
 	s.stop("Form schema fetched.");
 	printDiffResult(result);
 }
-var diff_default$1 = define({
+var diff_default$2 = define({
 	name: "diff",
 	description: "Detect differences between schema file and current kintone form",
 	args: {
@@ -8171,17 +9112,17 @@ var diff_default$1 = define({
 		try {
 			await routeMultiApp(ctx.values, {
 				singleLegacy: async () => {
-					await runDiff$1(createCliContainer(resolveConfig(ctx.values)));
+					await runDiff(createCliContainer(resolveConfig(ctx.values)));
 				},
 				singleApp: async (app, projectConfig) => {
-					await runDiff$1(createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values)));
+					await runDiff(createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values)));
 				},
 				multiApp: async (plan, projectConfig) => {
 					await runMultiAppWithFailCheck(plan, async (app) => {
 						const container = createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values));
 						printAppHeader(app.name, app.appId);
-						await runDiff$1(container);
-					});
+						await runDiff(container);
+					}, "All schema diffs completed successfully.");
 				}
 			});
 		} catch (error) {
@@ -8899,7 +9840,7 @@ var schema_default = define({
 	name: "schema",
 	description: "Manage kintone form schemas",
 	subCommands: {
-		diff: diff_default$1,
+		diff: diff_default$2,
 		migrate: migrate_default,
 		override: override_default,
 		capture: capture_default$3,
@@ -9497,6 +10438,91 @@ var capture_default$1 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/generalSettings/services/diffDetector.ts
+const DEFAULT_STRING = "";
+const DEFAULT_BOOLEAN = false;
+const DEFAULT_FIRST_MONTH = 1;
+function compareConfigs(local, remote) {
+	const entries = [];
+	function compareString(field, l, r, defaultValue, suppressValues = false) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: suppressValues ? `${field} changed` : `"${rv}" -> "${lv}"`
+		});
+	}
+	function compareBoolean(field, l, r, defaultValue) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: `${String(rv)} -> ${String(lv)}`
+		});
+	}
+	function compareNumber(field, l, r, defaultValue) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: `${rv} -> ${lv}`
+		});
+	}
+	function compareDeepEqual(field, l, r) {
+		if (!deepEqual$1(l, r)) entries.push({
+			type: "modified",
+			field,
+			details: `${field} changed`
+		});
+	}
+	compareString("name", local.name, remote.name, DEFAULT_STRING);
+	compareString("description", local.description, remote.description, DEFAULT_STRING, true);
+	compareDeepEqual("icon", local.icon, remote.icon);
+	compareString("theme", local.theme, remote.theme, DEFAULT_STRING);
+	compareDeepEqual("titleField", local.titleField, remote.titleField);
+	compareBoolean("enableThumbnails", local.enableThumbnails, remote.enableThumbnails, DEFAULT_BOOLEAN);
+	compareBoolean("enableBulkDeletion", local.enableBulkDeletion, remote.enableBulkDeletion, DEFAULT_BOOLEAN);
+	compareBoolean("enableComments", local.enableComments, remote.enableComments, DEFAULT_BOOLEAN);
+	compareBoolean("enableDuplicateRecord", local.enableDuplicateRecord, remote.enableDuplicateRecord, DEFAULT_BOOLEAN);
+	compareBoolean("enableInlineRecordEditing", local.enableInlineRecordEditing, remote.enableInlineRecordEditing, DEFAULT_BOOLEAN);
+	compareDeepEqual("numberPrecision", local.numberPrecision, remote.numberPrecision);
+	compareNumber("firstMonthOfFiscalYear", local.firstMonthOfFiscalYear, remote.firstMonthOfFiscalYear, DEFAULT_FIRST_MONTH);
+	return entries;
+}
+const GeneralSettingsDiffDetector = { detect: (local, remote) => {
+	return buildDiffResult(compareConfigs(local, remote));
+} };
+
+//#endregion
+//#region src/core/application/generalSettings/detectGeneralSettingsDiff.ts
+async function detectGeneralSettingsDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.generalSettingsStorage.get(),
+		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
+		parseConfig: parseGeneralSettingsConfigText,
+		detect: (local, remote) => GeneralSettingsDiffDetector.detect(local, remote.config),
+		notFoundMessage: "General settings config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/settings/diff.ts
+var diff_default$1 = createDiffCommand({
+	description: "Compare local general settings config with remote kintone app",
+	args: settingsArgs,
+	spinnerMessage: "Comparing general settings...",
+	multiAppSuccessMessage: "All general settings diffs completed successfully.",
+	createContainer: createGeneralSettingsCliContainer,
+	detectDiff: detectGeneralSettingsDiff,
+	printResult: printGeneralSettingsDiffResult,
+	resolveContainerConfig: resolveSettingsContainerConfig,
+	resolveAppContainerConfig: resolveSettingsAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/settings/index.ts
 var settings_default = define({
@@ -9504,7 +10530,8 @@ var settings_default = define({
 	description: "Manage kintone general settings",
 	subCommands: {
 		apply: apply_default$1,
-		capture: capture_default$1
+		capture: capture_default$1,
+		diff: diff_default$1
 	},
 	run: () => {}
 });
@@ -9693,37 +10720,21 @@ var capture_default = define({
 
 //#endregion
 //#region src/core/domain/view/services/diffDetector.ts
-function isArrayEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
 function describeChanges(local, remote) {
 	const changes = [];
+	if (local.name !== remote.name) changes.push(`name: "${remote.name}" -> "${local.name}"`);
 	if (local.type !== remote.type) changes.push(`type: ${remote.type} -> ${local.type}`);
+	if ((local.builtinType ?? "") !== (remote.builtinType ?? "")) changes.push("builtinType changed");
 	if (local.index !== remote.index) changes.push(`index: ${remote.index} -> ${local.index}`);
 	if ((local.filterCond ?? "") !== (remote.filterCond ?? "")) changes.push("filterCond changed");
 	if ((local.sort ?? "") !== (remote.sort ?? "")) changes.push("sort changed");
 	if ((local.date ?? "") !== (remote.date ?? "")) changes.push("date changed");
 	if ((local.title ?? "") !== (remote.title ?? "")) changes.push("title changed");
 	if ((local.html ?? "") !== (remote.html ?? "")) changes.push("html changed");
-	if (local.pager !== remote.pager) changes.push(`pager: ${String(remote.pager ?? "undefined")} -> ${String(local.pager ?? "undefined")}`);
+	if ((local.pager ?? false) !== (remote.pager ?? false)) changes.push(`pager: ${String(remote.pager ?? false)} -> ${String(local.pager ?? false)}`);
 	if ((local.device ?? "") !== (remote.device ?? "")) changes.push("device changed");
-	if (!isArrayEqual(local.fields ?? [], remote.fields ?? [])) changes.push("fields changed");
-	return changes.length > 0 ? changes.join(", ") : "no visible changes";
-}
-function isViewEqual(local, remote) {
-	if (local.type !== remote.type) return false;
-	if (local.index !== remote.index) return false;
-	if ((local.filterCond ?? "") !== (remote.filterCond ?? "")) return false;
-	if ((local.sort ?? "") !== (remote.sort ?? "")) return false;
-	if ((local.date ?? "") !== (remote.date ?? "")) return false;
-	if ((local.title ?? "") !== (remote.title ?? "")) return false;
-	if ((local.html ?? "") !== (remote.html ?? "")) return false;
-	if (local.pager !== remote.pager) return false;
-	if ((local.device ?? "") !== (remote.device ?? "")) return false;
-	if (!isArrayEqual(local.fields ?? [], remote.fields ?? [])) return false;
-	return true;
+	if (!deepEqual$1(local.fields ?? [], remote.fields ?? [])) changes.push("fields changed");
+	return changes;
 }
 const ViewDiffDetector = { detect: (localViews, remoteViews) => {
 	const entries = [];
@@ -9734,83 +10745,47 @@ const ViewDiffDetector = { detect: (localViews, remoteViews) => {
 			viewName: name,
 			details: "new view"
 		});
-		else if (!isViewEqual(localView, remoteView)) entries.push({
-			type: "modified",
-			viewName: name,
-			details: describeChanges(localView, remoteView)
-		});
+		else {
+			const changes = describeChanges(localView, remoteView);
+			if (changes.length > 0) entries.push({
+				type: "modified",
+				viewName: name,
+				details: changes.join(", ")
+			});
+		}
 	}
 	for (const name of Object.keys(remoteViews)) if (localViews[name] === void 0) entries.push({
 		type: "deleted",
 		viewName: name,
-		details: "deleted"
+		details: "removed"
 	});
-	const added = entries.filter((e) => e.type === "added").length;
-	const modified = entries.filter((e) => e.type === "modified").length;
-	const deleted = entries.filter((e) => e.type === "deleted").length;
-	return {
-		entries,
-		summary: {
-			added,
-			modified,
-			deleted,
-			total: added + modified + deleted
-		},
-		isEmpty: entries.length === 0
-	};
+	return buildDiffResult(entries);
 } };
 
 //#endregion
 //#region src/core/application/view/detectViewDiff.ts
 async function detectViewDiff({ container }) {
-	const result = await container.viewStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "View config file not found");
-	const config = parseViewConfigText(result.content);
-	const { views: remoteViews } = await container.viewConfigurator.getViews();
-	const diff = ViewDiffDetector.detect(config.views, remoteViews);
-	return {
-		entries: diff.entries,
-		summary: diff.summary,
-		isEmpty: diff.isEmpty
-	};
+	return detectDiffFromConfig({
+		getStorage: () => container.viewStorage.get(),
+		fetchRemote: () => container.viewConfigurator.getViews(),
+		parseConfig: (content) => parseViewConfigText(content).views,
+		detect: (views, remote) => ViewDiffDetector.detect(views, remote.views),
+		notFoundMessage: "View config file not found"
+	});
 }
 
 //#endregion
 //#region src/cli/commands/view/diff.ts
-async function runDiff(config) {
-	const container = createViewCliContainer(config);
-	const s = p.spinner();
-	s.start("Fetching views...");
-	const result = await detectViewDiff({ container });
-	s.stop("Views fetched.");
-	printViewDiffResult(result);
-}
-var diff_default = define({
-	name: "diff",
-	description: "Detect differences between view config file and current kintone views",
+var diff_default = createDiffCommand({
+	description: "Compare local view config with remote kintone app",
 	args: viewArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runDiff(resolveViewContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runDiff(resolveViewAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveViewAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runDiff(config);
-					});
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Comparing view settings...",
+	multiAppSuccessMessage: "All view diffs completed successfully.",
+	createContainer: createViewCliContainer,
+	detectDiff: detectViewDiff,
+	printResult: printViewDiffResult,
+	resolveContainerConfig: resolveViewContainerConfig,
+	resolveAppContainerConfig: resolveViewAppContainerConfig
 });
 
 //#endregion