feat: implement core git JSON conflict resolution system

- Add main resolver entry point with conflict processing pipeline
- Implement JSON/YAML file parsing and serialization
- Add intelligent merge strategies with conflict detection
- Create backup system and file matching utilities
- Add comprehensive logging and error handling
- Include strategy resolver for custom merge logic
- Add conflict reconstruction for unresolved conflicts
- Update package configuration and dependencies

Author: mayank1513

lib/package.json

@@ -43,7 +43,7 @@
     "json5": "^2.2.3",
     "micromatch": "^4.0.8",
     "picomatch": "^4.0.3",
-    "toml": "^3.0.0",
+    "smol-toml": "^1.4.2",
     "tsup": "^8.5.0",
     "typescript": "^5.9.2",
     "vite-tsconfig-paths": "^5.1.4",
@@ -80,7 +80,7 @@
     "json5": "^2.2.3",
     "micromatch": "^4.0.8",
     "picomatch": "^4.0.3",
-    "toml": "^3.0.0",
+    "smol-toml": "^1.4.2",
     "yaml": "^2.8.1"
   },
   "peerDependenciesMeta": {
@@ -96,7 +96,7 @@
     "picomatch": {
       "optional": true
     },
-    "toml": {
+    "smol-toml": {
       "optional": true
     },
     "yaml": {

lib/src.zip

@@ -0,0 +1,81 @@
+import { serialize } from "./file-serializer";
+import { DROP } from "./merger";
+
+/** Remove DROP, replace undefined with conflict markers */
+const preprocessForConflicts = (node: any, path: string, conflicts: string[] = []): any => {
+  if (node === DROP) {
+    return undefined; // remove key later
+  }
+  if (node === undefined) {
+    const marker = `__CONFLICT_MARKER::${path}__`;
+    conflicts.push(path);
+    return marker;
+  }
+  if (Array.isArray(node)) {
+    return node
+      .map((v, i) => preprocessForConflicts(v, `${path}[${i}]`, conflicts))
+      .filter(v => v !== undefined);
+  }
+  if (node && typeof node === "object") {
+    const out: Record<string, any> = {};
+    for (const [k, v] of Object.entries(node)) {
+      const val = preprocessForConflicts(v, path ? `${path}.${k}` : k, conflicts);
+      if (val !== undefined) out[k] = val;
+    }
+    return out;
+  }
+  return node;
+};
+
+/** Build conflict markers into serialized string */
+export const reconstructConflict = async (
+  merged: any,
+  ours: any,
+  theirs: any,
+  format: string,
+): Promise<string> => {
+  const conflictPaths: string[] = [];
+  const preprocessed = preprocessForConflicts(merged, "", conflictPaths);
+  let serialized = await serialize(format, preprocessed);
+
+  for (const path of conflictPaths) {
+    const oursVal = getByPath(ours, path);
+    const theirsVal = getByPath(theirs, path);
+
+    const oursStr = await serialize(format, oursVal);
+    const theirsStr = await serialize(format, theirsVal);
+
+    const block = [
+      "<<<<<<< ours",
+      indentBlock(oursStr, 2),
+      "=======",
+      indentBlock(theirsStr, 2),
+      ">>>>>>> theirs",
+    ].join("\n");
+
+    serialized = serialized.replace(
+      JSON.stringify(`__CONFLICT_MARKER::${path}__`), // works for JSON
+      block,
+    );
+  }
+
+  return serialized;
+};
+
+const getByPath = (obj: any, path: string): any => {
+  const parts = path
+    .replace(/\[(\d+)\]/g, ".$1")
+    .split(".")
+    .filter(Boolean);
+  let cur = obj;
+  for (const p of parts) cur = cur?.[p];
+  return cur;
+};
+
+const indentBlock = (str: string, spaces: number) => {
+  const pad = " ".repeat(spaces);
+  return str
+    .split("\n")
+    .map(line => (line ? pad + line : line))
+    .join("\n");
+};

lib/src/conflict-helper.ts

@@ -13,7 +13,7 @@ export interface ParsedConflict<T = unknown> {
 }
 
 /** A parser function that takes a raw string and returns parsed content. */
-export type Parser = (input: string) => unknown;
+export type Parser = { name: string; parser: (input: string) => unknown };
 
 /** Built-in parser identifiers or a custom parser function. */
 export type SupportedParsers = "json" | "json5" | "yaml" | "toml" | "xml" | Parser;
@@ -116,34 +116,34 @@ export const parseConflictContent = async <T = unknown>(
   return {
     ours: oursParsed as T,
     theirs: theirsParsed as T,
-    format: typeof format === "function" ? "custom" : format,
+    format: typeof format === "string" ? format : format.name,
   };
 };
 
+const FILE_EXTENSION_TO_PARSER_MAP: Record<string, SupportedParsers> = {
+  json: "json",
+  json5: "json5",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  xml: "xml",
+};
+
 /** Normalize parsers based on filename + options. */
 const normalizeParsers = (options: ParseConflictOptions): SupportedParsers[] => {
+  if (Array.isArray(options.parsers)) return options.parsers;
+
   if (options.parsers) {
-    return Array.isArray(options.parsers)
-      ? options.parsers
-      : options.parsers === "auto"
-        ? ["json", "json5", "yaml", "toml", "xml"]
-        : [options.parsers];
+    return options.parsers === "auto"
+      ? ["json", "json5", "yaml", "toml", "xml"]
+      : [options.parsers];
   }
 
   if (options.filename) {
-    const ext = options.filename.split(".").pop()?.toLowerCase();
-    switch (ext) {
-      case "json":
-        return ["json"];
-      case "json5":
-        return ["json5"];
-      case "yaml":
-      case "yml":
-        return ["yaml"];
-      case "toml":
-        return ["toml"];
-      case "xml":
-        return ["xml"];
+    const parserBasedOnExt =
+      FILE_EXTENSION_TO_PARSER_MAP[options.filename.split(".").pop()?.toLowerCase() ?? ""];
+    if (parserBasedOnExt) {
+      return [parserBasedOnExt];
     }
   }
 
@@ -157,7 +157,7 @@ const runParser = async (
 ): Promise<[unknown, SupportedParsers]> => {
   for (const parser of parsers) {
     try {
-      if (typeof parser === "function") return [parser(raw), parser];
+      if (typeof parser !== "string") return [parser.parser(raw), parser];
       return [await parseFormat(parser, raw), parser];
     } catch (err) {
       console.debug(`Parser ${typeof parser === "function" ? "custom" : parser} failed:`, err);
@@ -194,7 +194,7 @@ const parseFormat = async (
     }
     case "toml": {
       try {
-        const { parse } = await import("toml");
+        const { parse } = await import("smol-toml");
         return parse(raw);
       } catch {
         throw new Error("toml parser not installed. Please install as peer dependency.");

lib/src/file-parser.ts

@@ -0,0 +1,21 @@
+export const serialize = async (format: string, value: unknown): Promise<string> => {
+  switch (format) {
+    case "json":
+    case "json5":
+      return JSON.stringify(value, null, 2);
+    case "yaml": {
+      const { stringify } = await import("yaml");
+      return stringify(value);
+    }
+    case "toml": {
+      const { stringify } = await import("smol-toml");
+      return stringify(value as any);
+    }
+    case "xml": {
+      const { XMLBuilder } = await import("fast-xml-parser");
+      return new XMLBuilder({}).build(value);
+    }
+    default:
+      throw new Error(`Unknown format: ${format}`);
+  }
+};

lib/src/file-serializer.ts

@@ -0,0 +1,52 @@
+import { execSync } from "node:child_process";
+import { parseConflictContent } from "./file-parser";
+import { serialize } from "./file-serializer";
+import { Conflict, mergeObject } from "./merger";
+import { normalizeConfig, NormalizedConfig } from "./normalizer";
+import { Config } from "./types";
+import { backupFile, listMatchingFiles } from "./utils";
+import fs from "node:fs/promises";
+import { reconstructConflict } from "./conflict-helper";
+
+const _strategyCache = new Map<string, string[]>();
+
+export const resolveConflicts = async (config: Config) => {
+  const normalizedConfig: NormalizedConfig = await normalizeConfig(config);
+  const filesEntries = await listMatchingFiles(normalizedConfig);
+  await Promise.all(
+    filesEntries.map(async ({ filePath, content }) => {
+      const { theirs, ours, format } = await parseConflictContent(content, { filename: filePath });
+      const conflicts: Conflict[] = [];
+      const [merged] = await Promise.all([
+        mergeObject({
+          ours,
+          theirs,
+          base: undefined,
+          filePath,
+          conflicts,
+          path: "",
+          ctx: {
+            config: normalizedConfig,
+            strategies: normalizedConfig.customStrategies,
+            _strategyCache,
+          },
+        }),
+        backupFile(filePath),
+      ]);
+
+      if (conflicts.length === 0) {
+        const serialized = await serialize(format, merged);
+        await fs.writeFile(filePath, serialized, "utf8");
+        execSync(`git add ${filePath}`);
+      } else {
+        const serialized = await reconstructConflict(merged, ours, theirs, format);
+        await Promise.all([
+          fs.writeFile(filePath, serialized, "utf8"),
+          config.writeConflictSidecar
+            ? fs.writeFile(`${filePath}.conflict.json`, JSON.stringify(conflicts, null, 2))
+            : null,
+        ]);
+      }
+    }),
+  );
+};

lib/src/index.ts

@@ -0,0 +1,87 @@
+import fs from "fs";
+import path from "path";
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+
+type Mode = "memory" | "stream";
+
+interface LoggerConfig {
+  mode?: Mode; // default: "memory"
+  logDir?: string; // default: "logs"
+  singleFile?: boolean; // default: false (per input file logs)
+  levels?: {
+    stdout?: LogLevel[]; // default: ["warn", "error"]
+    file?: LogLevel[]; // default: ["info", "warn", "error"]
+  };
+}
+
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+}
+
+export const createLogger = (config: LoggerConfig = {}) => {
+  const mode: Mode = config.mode ?? "memory";
+  const logDir = config.logDir ?? "logs";
+  const singleFile = config.singleFile ?? false;
+  const levels = {
+    stdout: config.levels?.stdout ?? ["warn", "error"],
+    file: config.levels?.file ?? ["info", "warn", "error"],
+  };
+
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+
+  const buffers = new Map<string, LogEntry[]>();
+  const streams = new Map<string, fs.WriteStream>();
+
+  const getStream = (fileId: string) => {
+    const key = singleFile ? "all" : fileId;
+    if (!streams.has(key)) {
+      const filePath = path.join(logDir, singleFile ? "combined.log" : `${fileId}.log`);
+      streams.set(key, fs.createWriteStream(filePath, { flags: "a" }));
+    }
+    return streams.get(key)!;
+  };
+
+  const write = (fileId: string, level: LogLevel, message: string) => {
+    const entry: LogEntry = { timestamp: new Date().toISOString(), level, message };
+
+    // Console output if enabled
+    if (levels.stdout.includes(level)) {
+      const fn = level === "error" ? console.error : console.log;
+      fn(`[${fileId}] [${entry.timestamp}] [${level.toUpperCase()}] ${entry.message}`);
+    }
+
+    // File output
+    if (levels.file.includes(level)) {
+      if (mode === "memory") {
+        if (!buffers.has(fileId)) buffers.set(fileId, []);
+        buffers.get(fileId)!.push(entry);
+      } else {
+        getStream(fileId).write(`[${entry.timestamp}] [${level.toUpperCase()}] ${entry.message}\n`);
+      }
+    }
+  };
+
+  const flush = () => {
+    if (mode === "memory") {
+      for (const [fileId, entries] of buffers.entries()) {
+        const filePath = path.join(logDir, singleFile ? "combined.log" : `${fileId}.log`);
+        const lines = entries.map(e => `[${e.timestamp}] [${e.level.toUpperCase()}] ${e.message}`);
+        fs.writeFileSync(filePath, lines.join("\n") + "\n", { flag: "a" });
+      }
+    }
+    for (const s of streams.values()) s.end();
+  };
+
+  return {
+    info: (fileId: string, msg: string) => write(fileId, "info", msg),
+    warn: (fileId: string, msg: string) => write(fileId, "warn", msg),
+    error: (fileId: string, msg: string) => write(fileId, "error", msg),
+    debug: (fileId: string, msg: string) => write(fileId, "debug", msg),
+    flush,
+  };
+};
+
+export const globalLogger = createLogger();