@leynier/ccst 0.2.1 → 0.3.1

package/src/core/merge-manager.test.ts

@@ -1,38 +1,53 @@
-import { test, expect } from "bun:test";
-import { mergePermissions, mergeFull, unmergePermissions, unmergeFull } from "./merge-manager.js";
+import { expect, test } from "bun:test";
+import {
+	mergeFull,
+	mergePermissions,
+	unmergeFull,
+	unmergePermissions,
+} from "./merge-manager.js";
 
-const base = () => ({ permissions: { allow: ["a"], deny: [] }, env: { A: "1" }, other: 1 });
-const source = () => ({ permissions: { allow: ["b"], deny: ["x"] }, env: { B: "2" }, other2: true });
+const base = () => ({
+	permissions: { allow: ["a"], deny: [] },
+	env: { A: "1" },
+	other: 1,
+});
+const source = () => ({
+	permissions: { allow: ["b"], deny: ["x"] },
+	env: { B: "2" },
+	other2: true,
+});
 
 test("mergePermissions adds allow/deny and records items", () => {
-  const target = base();
-  const entry = mergePermissions(target, source(), "source");
-  expect((target.permissions as { allow: string[] }).allow).toContain("b");
-  expect((target.permissions as { deny: string[] }).deny).toContain("x");
-  expect(entry.mergedItems.some((item) => item.includes("permissions.allow"))).toBe(true);
+	const target = base();
+	const entry = mergePermissions(target, source(), "source");
+	expect((target.permissions as { allow: string[] }).allow).toContain("b");
+	expect((target.permissions as { deny: string[] }).deny).toContain("x");
+	expect(
+		entry.mergedItems.some((item) => item.includes("permissions.allow")),
+	).toBe(true);
 });
 
 test("mergeFull merges env and top-level keys", () => {
-  const target = base();
-  const entry = mergeFull(target, source(), "source");
-  expect((target.env as Record<string, string>).B).toBe("2");
-  expect(target.other2).toBe(true);
-  expect(entry.mergedItems.some((item) => item.startsWith("env:"))).toBe(true);
+	const target = base();
+	const entry = mergeFull(target, source(), "source");
+	expect((target.env as Record<string, string>).B).toBe("2");
+	expect(target.other2).toBe(true);
+	expect(entry.mergedItems.some((item) => item.startsWith("env:"))).toBe(true);
 });
 
 test("unmergePermissions removes merged items", () => {
-  const target = base();
-  const history = [mergePermissions(target, source(), "source")];
-  const remaining = unmergePermissions(target, history, "source");
-  expect(remaining.length).toBe(0);
-  expect((target.permissions as { allow: string[] }).allow).not.toContain("b");
+	const target = base();
+	const history = [mergePermissions(target, source(), "source")];
+	const remaining = unmergePermissions(target, history, "source");
+	expect(remaining.length).toBe(0);
+	expect((target.permissions as { allow: string[] }).allow).not.toContain("b");
 });
 
 test("unmergeFull removes merged items and history", () => {
-  const target = base();
-  const history = [mergeFull(target, source(), "source")];
-  const remaining = unmergeFull(target, history, "source");
-  expect(remaining.length).toBe(0);
-  expect((target.env as Record<string, string>).B).toBeUndefined();
-  expect(target.other2).toBeUndefined();
+	const target = base();
+	const history = [mergeFull(target, source(), "source")];
+	const remaining = unmergeFull(target, history, "source");
+	expect(remaining.length).toBe(0);
+	expect((target.env as Record<string, string>).B).toBeUndefined();
+	expect(target.other2).toBeUndefined();
 });

package/src/core/merge-manager.ts

@@ -1,152 +1,202 @@
-import path from "node:path";
 import { existsSync } from "node:fs";
+import path from "node:path";
 import type { MergeHistory, MergeHistoryEntry } from "../types/index.js";
 
-const ensurePermissions = (json: Record<string, unknown>): { allow: string[]; deny: string[] } => {
-  const permissions = (json.permissions as Record<string, unknown> | undefined) ?? {};
-  const allow = Array.isArray(permissions.allow) ? permissions.allow.slice() : [];
-  const deny = Array.isArray(permissions.deny) ? permissions.deny.slice() : [];
-  json.permissions = { ...permissions, allow, deny };
-  return { allow, deny };
+const ensurePermissions = (
+	json: Record<string, unknown>,
+): { allow: string[]; deny: string[] } => {
+	const permissions =
+		(json.permissions as Record<string, unknown> | undefined) ?? {};
+	const allow = Array.isArray(permissions.allow)
+		? permissions.allow.slice()
+		: [];
+	const deny = Array.isArray(permissions.deny) ? permissions.deny.slice() : [];
+	json.permissions = { ...permissions, allow, deny };
+	return { allow, deny };
 };
 
-export const mergePermissions = (target: Record<string, unknown>, source: Record<string, unknown>, sourceLabel: string): MergeHistoryEntry => {
-  const { allow, deny } = ensurePermissions(target);
-  const sourcePermissions = (source.permissions as Record<string, unknown> | undefined) ?? {};
-  const sourceAllow = Array.isArray(sourcePermissions.allow) ? sourcePermissions.allow : [];
-  const sourceDeny = Array.isArray(sourcePermissions.deny) ? sourcePermissions.deny : [];
-  const mergedItems: string[] = [];
-  const allowSet = new Set(allow);
-  const denySet = new Set(deny);
-  for (const item of sourceAllow) {
-    if (!allowSet.has(item)) {
-      allowSet.add(item);
-      mergedItems.push(`permissions.allow:${item}`);
-    }
-  }
-  for (const item of sourceDeny) {
-    if (!denySet.has(item)) {
-      denySet.add(item);
-      mergedItems.push(`permissions.deny:${item}`);
-    }
-  }
-  (target.permissions as Record<string, unknown>).allow = Array.from(allowSet);
-  (target.permissions as Record<string, unknown>).deny = Array.from(denySet);
-  return {
-    source: sourceLabel,
-    mergedItems,
-    timestamp: new Date().toISOString(),
-  };
+export const mergePermissions = (
+	target: Record<string, unknown>,
+	source: Record<string, unknown>,
+	sourceLabel: string,
+): MergeHistoryEntry => {
+	const { allow, deny } = ensurePermissions(target);
+	const sourcePermissions =
+		(source.permissions as Record<string, unknown> | undefined) ?? {};
+	const sourceAllow = Array.isArray(sourcePermissions.allow)
+		? sourcePermissions.allow
+		: [];
+	const sourceDeny = Array.isArray(sourcePermissions.deny)
+		? sourcePermissions.deny
+		: [];
+	const mergedItems: string[] = [];
+	const allowSet = new Set(allow);
+	const denySet = new Set(deny);
+	for (const item of sourceAllow) {
+		if (!allowSet.has(item)) {
+			allowSet.add(item);
+			mergedItems.push(`permissions.allow:${item}`);
+		}
+	}
+	for (const item of sourceDeny) {
+		if (!denySet.has(item)) {
+			denySet.add(item);
+			mergedItems.push(`permissions.deny:${item}`);
+		}
+	}
+	(target.permissions as Record<string, unknown>).allow = Array.from(allowSet);
+	(target.permissions as Record<string, unknown>).deny = Array.from(denySet);
+	return {
+		source: sourceLabel,
+		mergedItems,
+		timestamp: new Date().toISOString(),
+	};
 };
 
-export const mergeFull = (target: Record<string, unknown>, source: Record<string, unknown>, sourceLabel: string): MergeHistoryEntry => {
-  const mergedItems: string[] = [];
-  const permEntry = mergePermissions(target, source, sourceLabel);
-  mergedItems.push(...permEntry.mergedItems);
-  const targetEnv = (target.env as Record<string, unknown> | undefined) ?? {};
-  const sourceEnv = (source.env as Record<string, unknown> | undefined) ?? {};
-  const nextEnv: Record<string, unknown> = { ...targetEnv };
-  for (const [key, value] of Object.entries(sourceEnv)) {
-    if (!(key in nextEnv)) {
-      nextEnv[key] = value;
-      mergedItems.push(`env:${key}`);
-    }
-  }
-  if (Object.keys(nextEnv).length > 0) {
-    target.env = nextEnv;
-  }
-  for (const [key, value] of Object.entries(source)) {
-    if (key === "permissions" || key === "env") {
-      continue;
-    }
-    if (!(key in target)) {
-      target[key] = value;
-      mergedItems.push(key);
-    }
-  }
-  return {
-    source: sourceLabel,
-    mergedItems,
-    timestamp: permEntry.timestamp,
-  };
+export const mergeFull = (
+	target: Record<string, unknown>,
+	source: Record<string, unknown>,
+	sourceLabel: string,
+): MergeHistoryEntry => {
+	const mergedItems: string[] = [];
+	const permEntry = mergePermissions(target, source, sourceLabel);
+	mergedItems.push(...permEntry.mergedItems);
+	const targetEnv = (target.env as Record<string, unknown> | undefined) ?? {};
+	const sourceEnv = (source.env as Record<string, unknown> | undefined) ?? {};
+	const nextEnv: Record<string, unknown> = { ...targetEnv };
+	for (const [key, value] of Object.entries(sourceEnv)) {
+		if (!(key in nextEnv)) {
+			nextEnv[key] = value;
+			mergedItems.push(`env:${key}`);
+		}
+	}
+	if (Object.keys(nextEnv).length > 0) {
+		target.env = nextEnv;
+	}
+	for (const [key, value] of Object.entries(source)) {
+		if (key === "permissions" || key === "env") {
+			continue;
+		}
+		if (!(key in target)) {
+			target[key] = value;
+			mergedItems.push(key);
+		}
+	}
+	return {
+		source: sourceLabel,
+		mergedItems,
+		timestamp: permEntry.timestamp,
+	};
 };
 
-export const unmergePermissions = (target: Record<string, unknown>, history: MergeHistory, sourceLabel: string): MergeHistory => {
-  const { allow, deny } = ensurePermissions(target);
-  const allowSet = new Set(allow);
-  const denySet = new Set(deny);
-  const remainingHistory = history.filter((entry) => entry.source !== sourceLabel);
-  const removedEntries = history.filter((entry) => entry.source === sourceLabel);
-  for (const entry of removedEntries) {
-    for (const item of entry.mergedItems) {
-      if (item.startsWith("permissions.allow:")) {
-        allowSet.delete(item.replace("permissions.allow:", ""));
-      }
-      if (item.startsWith("permissions.deny:")) {
-        denySet.delete(item.replace("permissions.deny:", ""));
-      }
-    }
-  }
-  (target.permissions as Record<string, unknown>).allow = Array.from(allowSet);
-  (target.permissions as Record<string, unknown>).deny = Array.from(denySet);
-  return remainingHistory;
+export const unmergePermissions = (
+	target: Record<string, unknown>,
+	history: MergeHistory,
+	sourceLabel: string,
+): MergeHistory => {
+	const { allow, deny } = ensurePermissions(target);
+	const allowSet = new Set(allow);
+	const denySet = new Set(deny);
+	const remainingHistory = history.filter(
+		(entry) => entry.source !== sourceLabel,
+	);
+	const removedEntries = history.filter(
+		(entry) => entry.source === sourceLabel,
+	);
+	for (const entry of removedEntries) {
+		for (const item of entry.mergedItems) {
+			if (item.startsWith("permissions.allow:")) {
+				allowSet.delete(item.replace("permissions.allow:", ""));
+			}
+			if (item.startsWith("permissions.deny:")) {
+				denySet.delete(item.replace("permissions.deny:", ""));
+			}
+		}
+	}
+	(target.permissions as Record<string, unknown>).allow = Array.from(allowSet);
+	(target.permissions as Record<string, unknown>).deny = Array.from(denySet);
+	return remainingHistory;
 };
 
-export const unmergeFull = (target: Record<string, unknown>, history: MergeHistory, sourceLabel: string): MergeHistory => {
-  const remainingHistory = history.filter((entry) => entry.source !== sourceLabel);
-  const removedEntries = history.filter((entry) => entry.source === sourceLabel);
-  const targetEnv = (target.env as Record<string, unknown> | undefined) ?? {};
-  for (const entry of removedEntries) {
-    for (const item of entry.mergedItems) {
-      if (item.startsWith("permissions.allow:") || item.startsWith("permissions.deny:")) {
-        continue;
-      }
-      if (item.startsWith("env:")) {
-        const key = item.replace("env:", "");
-        delete targetEnv[key];
-        continue;
-      }
-      delete target[item];
-    }
-  }
-  if (Object.keys(targetEnv).length > 0) {
-    target.env = targetEnv;
-  } else {
-    delete target.env;
-  }
-  return unmergePermissions(target, remainingHistory, sourceLabel);
+export const unmergeFull = (
+	target: Record<string, unknown>,
+	history: MergeHistory,
+	sourceLabel: string,
+): MergeHistory => {
+	const remainingHistory = history.filter(
+		(entry) => entry.source !== sourceLabel,
+	);
+	const removedEntries = history.filter(
+		(entry) => entry.source === sourceLabel,
+	);
+	const targetEnv = (target.env as Record<string, unknown> | undefined) ?? {};
+	for (const entry of removedEntries) {
+		for (const item of entry.mergedItems) {
+			if (
+				item.startsWith("permissions.allow:") ||
+				item.startsWith("permissions.deny:")
+			) {
+				continue;
+			}
+			if (item.startsWith("env:")) {
+				const key = item.replace("env:", "");
+				delete targetEnv[key];
+				continue;
+			}
+			delete target[item];
+		}
+	}
+	if (Object.keys(targetEnv).length > 0) {
+		target.env = targetEnv;
+	} else {
+		delete target.env;
+	}
+	return unmergePermissions(target, remainingHistory, sourceLabel);
 };
 
-export const historyPath = (contextsDir: string, contextName: string): string => {
-  return path.join(contextsDir, `.${contextName}-merge-history.json`);
+export const historyPath = (
+	contextsDir: string,
+	contextName: string,
+): string => {
+	return path.join(contextsDir, `.${contextName}-merge-history.json`);
 };
 
-export const loadHistory = async (contextsDir: string, contextName: string): Promise<MergeHistory> => {
-  const filePath = historyPath(contextsDir, contextName);
-  if (!existsSync(filePath)) {
-    return [];
-  }
-  const text = await Bun.file(filePath).text();
-  return JSON.parse(text) as MergeHistory;
+export const loadHistory = async (
+	contextsDir: string,
+	contextName: string,
+): Promise<MergeHistory> => {
+	const filePath = historyPath(contextsDir, contextName);
+	if (!existsSync(filePath)) {
+		return [];
+	}
+	const text = await Bun.file(filePath).text();
+	return JSON.parse(text) as MergeHistory;
 };
 
-export const saveHistory = async (contextsDir: string, contextName: string, history: MergeHistory): Promise<void> => {
-  const filePath = historyPath(contextsDir, contextName);
-  await Bun.write(filePath, `${JSON.stringify(history, null, 2)}\n`);
+export const saveHistory = async (
+	contextsDir: string,
+	contextName: string,
+	history: MergeHistory,
+): Promise<void> => {
+	const filePath = historyPath(contextsDir, contextName);
+	await Bun.write(filePath, `${JSON.stringify(history, null, 2)}\n`);
 };
 
-export const formatHistory = (contextName: string, history: MergeHistory): string => {
-  if (history.length === 0) {
-    return `No merge history for ${contextName}`;
-  }
-  const lines: string[] = [];
-  lines.push(`📋 Merge history for context '${contextName}':`);
-  lines.push("");
-  for (const entry of history) {
-    lines.push(`  📅 ${entry.timestamp}`);
-    lines.push(`  📁 Source: ${entry.source}`);
-    lines.push(`  📝 Merged ${entry.mergedItems.length} items`);
-    lines.push("");
-  }
-  return lines.join("\n");
+export const formatHistory = (
+	contextName: string,
+	history: MergeHistory,
+): string => {
+	if (history.length === 0) {
+		return `No merge history for ${contextName}`;
+	}
+	const lines: string[] = [];
+	lines.push(`📋 Merge history for context '${contextName}':`);
+	lines.push("");
+	for (const entry of history) {
+		lines.push(`  📅 ${entry.timestamp}`);
+		lines.push(`  📁 Source: ${entry.source}`);
+		lines.push(`  📝 Merged ${entry.mergedItems.length} items`);
+		lines.push("");
+	}
+	return lines.join("\n");
 };

package/src/core/settings-level.ts

@@ -1,11 +1,14 @@
 import type { SettingsLevel } from "../types/index.js";
 
-export const resolveSettingsLevel = (opts: { local?: boolean; inProject?: boolean }): SettingsLevel => {
-  if (opts.local) {
-    return "local";
-  }
-  if (opts.inProject) {
-    return "project";
-  }
-  return "user";
+export const resolveSettingsLevel = (opts: {
+	local?: boolean;
+	inProject?: boolean;
+}): SettingsLevel => {
+	if (opts.local) {
+		return "local";
+	}
+	if (opts.inProject) {
+		return "project";
+	}
+	return "user";
 };

package/src/core/state.ts

@@ -2,28 +2,33 @@ import type { State } from "../types/index.js";
 import { readJsonIfExists, writeJson } from "../utils/json.js";
 
 export const loadState = async (statePath: string): Promise<State> => {
-  return readJsonIfExists<State>(statePath, {});
+	return readJsonIfExists<State>(statePath, {});
 };
 
-export const saveState = async (statePath: string, state: State): Promise<void> => {
-  await writeJson(statePath, state);
+export const saveState = async (
+	statePath: string,
+	state: State,
+): Promise<void> => {
+	await writeJson(statePath, state);
 };
 
 export const setCurrent = (state: State, context: string): State => {
-  const next: State = { ...state };
-  if (next.current && next.current !== context) {
-    next.previous = next.current;
-  }
-  next.current = context;
-  return next;
+	const next: State = { ...state };
+	if (next.current && next.current !== context) {
+		next.previous = next.current;
+	}
+	next.current = context;
+	return next;
 };
 
-export const unsetCurrent = (state: State): { state: State; previous?: string } => {
-  const next: State = { ...state };
-  const current = next.current;
-  delete next.current;
-  if (current) {
-    next.previous = current;
-  }
-  return { state: next, previous: current };
+export const unsetCurrent = (
+	state: State,
+): { state: State; previous?: string } => {
+	const next: State = { ...state };
+	const current = next.current;
+	delete next.current;
+	if (current) {
+		next.previous = current;
+	}
+	return { state: next, previous: current };
 };