@aprovan/hardcopy 0.1.0

package/src/conflict-store.ts

@@ -0,0 +1,136 @@
+import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import matter from "gray-matter";
+import type { ConflictInfo, FieldConflict } from "./types";
+import { generateConflictMarkers } from "./conflict";
+
+export class ConflictStore {
+  private conflictsDir: string;
+
+  constructor(conflictsDir: string) {
+    this.conflictsDir = conflictsDir;
+  }
+
+  async save(info: ConflictInfo): Promise<void> {
+    await mkdir(this.conflictsDir, { recursive: true });
+    const filePath = this.getPath(info.nodeId);
+    const body = formatConflictBody(info.fields);
+    const frontmatter = {
+      nodeId: info.nodeId,
+      nodeType: info.nodeType,
+      filePath: info.filePath,
+      detectedAt: new Date(info.detectedAt).toISOString(),
+      fields: info.fields.map((field) => ({
+        field: field.field,
+        status: field.status,
+        canAutoMerge: field.canAutoMerge,
+      })),
+    };
+
+    await writeFile(filePath, matter.stringify(body, frontmatter));
+  }
+
+  async list(): Promise<ConflictInfo[]> {
+    const entries = await readdir(this.conflictsDir).catch(() => []);
+    const conflicts: ConflictInfo[] = [];
+
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = join(this.conflictsDir, entry);
+      try {
+        const content = await readFile(fullPath, "utf-8");
+        const parsed = matter(content);
+        const data = parsed.data as Record<string, unknown>;
+        const fields = parseStoredFields(data["fields"]);
+        const detectedAt = Date.parse(String(data["detectedAt"] ?? ""));
+
+        conflicts.push({
+          nodeId: String(data["nodeId"] ?? ""),
+          nodeType: String(data["nodeType"] ?? ""),
+          filePath: String(data["filePath"] ?? ""),
+          detectedAt: Number.isNaN(detectedAt) ? 0 : detectedAt,
+          fields,
+        });
+      } catch {
+        continue;
+      }
+    }
+
+    return conflicts.filter((conflict) => conflict.nodeId.length > 0);
+  }
+
+  async get(nodeId: string): Promise<ConflictInfo | null> {
+    const result = await this.read(nodeId);
+    return result?.info ?? null;
+  }
+
+  async read(
+    nodeId: string,
+  ): Promise<{ info: ConflictInfo; body: string } | null> {
+    const filePath = this.getPath(nodeId);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const parsed = matter(content);
+      const data = parsed.data as Record<string, unknown>;
+      const fields = parseStoredFields(data["fields"]);
+      const detectedAt = Date.parse(String(data["detectedAt"] ?? ""));
+
+      const info = {
+        nodeId: String(data["nodeId"] ?? nodeId),
+        nodeType: String(data["nodeType"] ?? ""),
+        filePath: String(data["filePath"] ?? ""),
+        detectedAt: Number.isNaN(detectedAt) ? 0 : detectedAt,
+        fields,
+      };
+
+      return { info, body: parsed.content };
+    } catch {
+      return null;
+    }
+  }
+
+  async remove(nodeId: string): Promise<void> {
+    const filePath = this.getPath(nodeId);
+    try {
+      await rm(filePath, { force: true });
+    } catch {
+      return;
+    }
+  }
+
+  private getPath(nodeId: string): string {
+    return join(this.conflictsDir, `${encodeURIComponent(nodeId)}.md`);
+  }
+
+  getArtifactPath(nodeId: string): string {
+    return this.getPath(nodeId);
+  }
+}
+
+function parseStoredFields(value: unknown): FieldConflict[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item): FieldConflict | null => {
+      if (!item || typeof item !== "object") return null;
+      const record = item as Record<string, unknown>;
+      const field = String(record["field"] ?? "");
+      if (!field) return null;
+      return {
+        field,
+        status: String(record["status"] ?? "clean") as FieldConflict["status"],
+        canAutoMerge: Boolean(record["canAutoMerge"]),
+        base: null,
+        local: null,
+        remote: null,
+      };
+    })
+    .filter((item): item is FieldConflict => item !== null);
+}
+
+function formatConflictBody(fields: FieldConflict[]): string {
+  const blocks = fields
+    .filter((field) => field.status === "diverged")
+    .map((field) => `## ${field.field}\n${generateConflictMarkers(field)}`);
+
+  return blocks.join("\n\n");
+}

package/src/conflict.ts

@@ -0,0 +1,147 @@
+import type { ParsedFile } from "./format";
+import type { Node } from "./types";
+import {
+  ConflictStatus,
+  type FieldConflict,
+  type ThreeWayState,
+} from "./types";
+
+export function detectFieldConflict(
+  field: string,
+  state: ThreeWayState,
+): FieldConflict {
+  const localChanged = !valuesEqual(state.local, state.base);
+  const remoteChanged = !valuesEqual(state.remote, state.base);
+
+  let status: ConflictStatus;
+  if (!localChanged && !remoteChanged) {
+    status = ConflictStatus.CLEAN;
+  } else if (localChanged && !remoteChanged) {
+    status = ConflictStatus.CLEAN;
+  } else if (!localChanged && remoteChanged) {
+    status = ConflictStatus.REMOTE_ONLY;
+  } else if (valuesEqual(state.local, state.remote)) {
+    status = ConflictStatus.CLEAN;
+  } else {
+    status = ConflictStatus.DIVERGED;
+  }
+
+  return {
+    field,
+    status,
+    base: state.base,
+    local: state.local,
+    remote: state.remote,
+    canAutoMerge: isListField(state),
+  };
+}
+
+export function detectConflicts(
+  baseNode: Node,
+  localParsed: ParsedFile,
+  remoteNode: Node,
+  editableFields: string[],
+): FieldConflict[] {
+  const conflicts: FieldConflict[] = [];
+  const baseAttrs = baseNode.attrs as Record<string, unknown>;
+  const remoteAttrs = remoteNode.attrs as Record<string, unknown>;
+
+  for (const field of editableFields) {
+    const state: ThreeWayState =
+      field === "body"
+        ? {
+            base: (baseAttrs["body"] as string) ?? "",
+            local: localParsed.body ?? "",
+            remote: (remoteAttrs["body"] as string) ?? "",
+          }
+        : {
+            base: baseAttrs[field],
+            local: localParsed.attrs[field],
+            remote: remoteAttrs[field],
+          };
+
+    conflicts.push(detectFieldConflict(field, state));
+  }
+
+  return conflicts;
+}
+
+export function hasUnresolvableConflicts(conflicts: FieldConflict[]): boolean {
+  return conflicts.some(
+    (conflict) =>
+      conflict.status === ConflictStatus.DIVERGED && !conflict.canAutoMerge,
+  );
+}
+
+export function autoMergeField(conflict: FieldConflict): unknown | null {
+  if (conflict.status !== ConflictStatus.DIVERGED || !conflict.canAutoMerge) {
+    return null;
+  }
+
+  const merged = uniqueList([
+    ...(Array.isArray(conflict.base) ? conflict.base : []),
+    ...(Array.isArray(conflict.local) ? conflict.local : []),
+    ...(Array.isArray(conflict.remote) ? conflict.remote : []),
+  ]);
+
+  return merged;
+}
+
+export function generateConflictMarkers(conflict: FieldConflict): string {
+  const local = String(conflict.local ?? "");
+  const base = String(conflict.base ?? "");
+  const remote = String(conflict.remote ?? "");
+  return `<<<<<<< LOCAL\n${local}\n||||||| BASE\n${base}\n=======\n${remote}\n>>>>>>> REMOTE`;
+}
+
+export function parseConflictMarkers(text: string): {
+  local: string;
+  base: string;
+  remote: string;
+} | null {
+  const match = text.match(
+    /<<<<<<< LOCAL\r?\n([\s\S]*?)\r?\n\|\|\|\|\|\|\| BASE\r?\n([\s\S]*?)\r?\n=======\r?\n([\s\S]*?)\r?\n>>>>>>> REMOTE/,
+  );
+  if (!match) return null;
+  return {
+    local: match[1] ?? "",
+    base: match[2] ?? "",
+    remote: match[3] ?? "",
+  };
+}
+
+function valuesEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a == null && b == null) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const normalizedA = normalizeArray(a);
+    const normalizedB = normalizeArray(b);
+    if (normalizedA.length !== normalizedB.length) return false;
+    return normalizedA.every((value, index) => value === normalizedB[index]);
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function normalizeArray(values: unknown[]): string[] {
+  return values.map((value) => JSON.stringify(value)).sort();
+}
+
+function isListField(state: ThreeWayState): boolean {
+  return (
+    Array.isArray(state.base) ||
+    Array.isArray(state.local) ||
+    Array.isArray(state.remote)
+  );
+}
+
+function uniqueList(values: unknown[]): unknown[] {
+  const seen = new Set<string>();
+  const result: unknown[] = [];
+  for (const value of values) {
+    const key = JSON.stringify(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}

package/src/crdt.ts

@@ -0,0 +1,100 @@
+import { Loro, LoroDoc, LoroMap } from "loro-crdt";
+import { readFile, writeFile, mkdir, access, rm } from "fs/promises";
+import { dirname, join } from "path";
+
+export class CRDTStore {
+  private basePath: string;
+
+  constructor(basePath: string) {
+    this.basePath = basePath;
+  }
+
+  private getPath(nodeId: string): string {
+    const encoded = encodeURIComponent(nodeId);
+    return join(this.basePath, `${encoded}.loro`);
+  }
+
+  async exists(nodeId: string): Promise<boolean> {
+    try {
+      await access(this.getPath(nodeId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async load(nodeId: string): Promise<LoroDoc | null> {
+    const path = this.getPath(nodeId);
+    try {
+      const data = await readFile(path);
+      const doc = new LoroDoc();
+      doc.import(new Uint8Array(data));
+      return doc;
+    } catch {
+      return null;
+    }
+  }
+
+  async save(nodeId: string, doc: LoroDoc): Promise<void> {
+    const path = this.getPath(nodeId);
+    await mkdir(dirname(path), { recursive: true });
+    const snapshot = doc.export({ mode: "snapshot" });
+    await writeFile(path, Buffer.from(snapshot));
+  }
+
+  async create(nodeId: string): Promise<LoroDoc> {
+    const doc = new LoroDoc();
+    await this.save(nodeId, doc);
+    return doc;
+  }
+
+  async loadOrCreate(nodeId: string): Promise<LoroDoc> {
+    const existing = await this.load(nodeId);
+    if (existing) return existing;
+    return this.create(nodeId);
+  }
+
+  async delete(nodeId: string): Promise<void> {
+    try {
+      await rm(this.getPath(nodeId));
+    } catch {
+      // Ignore if not exists
+    }
+  }
+
+  async merge(nodeId: string, remote: LoroDoc): Promise<LoroDoc> {
+    const local = await this.loadOrCreate(nodeId);
+    local.import(remote.export({ mode: "update" }));
+    await this.save(nodeId, local);
+    return local;
+  }
+}
+
+export function setDocContent(doc: LoroDoc, content: string): void {
+  const text = doc.getText("body");
+  const current = text.toString();
+  if (current !== content) {
+    text.delete(0, current.length);
+    text.insert(0, content);
+  }
+}
+
+export function getDocContent(doc: LoroDoc): string {
+  return doc.getText("body").toString();
+}
+
+export function setDocAttrs(doc: LoroDoc, attrs: Record<string, unknown>): void {
+  const map = doc.getMap("attrs");
+  for (const [key, value] of Object.entries(attrs)) {
+    map.set(key, value);
+  }
+}
+
+export function getDocAttrs(doc: LoroDoc): Record<string, unknown> {
+  const map = doc.getMap("attrs");
+  const result: Record<string, unknown> = {};
+  for (const key of map.keys()) {
+    result[key] = map.get(key);
+  }
+  return result;
+}