create-flow-os 0.0.47-dev.1772051359 → 0.0.47-dev.1772051747

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "create-flow-os",
-  "version": "0.0.47-dev.1772051359",
+  "version": "0.0.47-dev.1772051747",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",
   "dependencies": {
-    "@flow-os/client": ">=0.0.1-dev.0"
+    "@flow-os/client": ">=0.0.1-dev.0",
+    "node-diff3": "^3.2.0"
   },
   "bin": {
     "create-flow-os": "./src/index.ts"

package/src/init/merge.ts

@@ -1,12 +1,21 @@
 /**
- * Merge generico per qualsiasi file: additivo (aggiunge, non toglie).
- * In conflitto: chiede all'utente.
+ * Merge generico per qualsiasi file.
+ * JSON: merge additivo. Code/altri: merge 3-way (tipo Git) quando possibile.
  */
 
 import * as readline from "readline";
+import { merge as diff3Merge } from "node-diff3";
 
 export type Conflict = { key: string; userVal: unknown; templateVal: unknown; path: string };
 
+/** Opzioni per merge 3-way: base (template precedente) e callback per salvare la nuova base */
+export type Merge3WayOptions = {
+  baseContent?: string;
+  saveBase?: (content: string) => void;
+};
+
+const LINE_SEP = /\n/;
+
 /** Deep merge di oggetti: aggiunge chiavi nuove, per esistenti chiede se diverso */
 function deepMergeAdditive(
   user: Record<string, unknown>,
@@ -30,71 +39,6 @@ function deepMergeAdditive(
   return out;
 }
 
-/** Trova la posizione della parentesi graffa di chiusura corrispondente */
-function findMatchingBrace(str: string, start: number): number {
-  let depth = 1;
-  for (let i = start; i < str.length; i++) {
-    if (str[i] === "{") depth++;
-    else if (str[i] === "}") {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-  return -1;
-}
-
-type Extracted = { obj: Record<string, unknown>; fullMatch: string; fn: string };
-
-/** Estrae oggetto da pattern fn({...}) o fn() nel contenuto - qualsiasi libreria */
-function extractObjectArg(content: string): Extracted | null {
-  const re = /(\w+)\s*\(\s*(\{)?/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(content)) !== null) {
-    const fn = m[1];
-    const openBrace = m[2];
-    const startIdx = m.index + m[0].length;
-    let arg = "";
-    let closeIdx = startIdx - 1;
-    if (openBrace === "{") {
-      closeIdx = findMatchingBrace(content, startIdx);
-      if (closeIdx >= 0) arg = content.slice(startIdx, closeIdx);
-    }
-    const parenIdx = content.indexOf(")", closeIdx + 1);
-    const fullMatch = parenIdx >= 0 ? content.slice(m.index, parenIdx + 1) : "";
-    if (arg && arg.trim()) {
-      try {
-        const obj = new Function("return " + "{" + arg + "}")() as Record<string, unknown>;
-        return { obj, fullMatch, fn };
-      } catch {
-        continue;
-      }
-    }
-    return { obj: {}, fullMatch, fn };
-  }
-  return null;
-}
-
-/** Serializza oggetto in formato JS compatibile */
-function serializeObject(obj: Record<string, unknown>): string {
-  const entries = Object.entries(obj)
-    .map(([k, v]) => {
-      const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
-      if (typeof v === "object" && v !== null && !Array.isArray(v)) {
-        return `${key}: ${serializeObject(v as Record<string, unknown>)}`;
-      }
-      return `${key}: ${JSON.stringify(v)}`;
-    })
-    .join(", ");
-  return `{ ${entries} }`;
-}
-
-/** Sostituisce l'argomento nella chiamata fn(...) con il nuovo oggetto */
-function replaceObjectArg(content: string, ext: Extracted, newObj: Record<string, unknown>): string {
-  const newArg = Object.keys(newObj).length > 0 ? serializeObject(newObj) : "";
-  const replacement = `${ext.fn}(${newArg})`;
-  return content.replace(ext.fullMatch, replacement);
-}
-
 /** Merge template+template (senza conflitti: il secondo vince) - per pre-merge pacchetti */
 function mergeTemplatesOnly(a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown> {
   const out = { ...a };
@@ -124,67 +68,24 @@ export function mergeJsonTemplates(a: string, b: string): string {
   return JSON.stringify(mergeTemplatesOnly(objA, objB), null, 2);
 }
 
-/** Merge template+template per code (sync, nessun conflitto) */
+/** Merge template+template per code: nessun merge automatico (evita corruzione). Il secondo vince. */
 export function mergeCodeTemplates(a: string, b: string): string {
-  const extA = extractObjectArg(a);
-  const extB = extractObjectArg(b);
-  if (!extB) return a || b;
-  const objA = extA?.obj ?? {};
-  const objB = extB.obj;
-  const merged = mergeTemplatesOnly(objA, objB);
-  const base = a || b;
-  return replaceObjectArg(base, extB, merged);
+  return b || a;
 }
 
-/** Pattern universali: aggiungi blocco solo se manca. Vale per tutti i file di tutti i package. */
-type AddIfMissingPattern = {
-  /** Controlla se il contenuto ha già questo (anche su righe diverse, formattazione diversa) */
-  hasSignature: (content: string) => boolean;
-  /** Estrae il blocco completo dal template da aggiungere */
-  extractBlock: (content: string) => string | null;
-};
-
-const ADD_IF_MISSING_PATTERNS: AddIfMissingPattern[] = [
-  {
-    hasSignature: (c) => /\bexport\s+default\b/.test(c.replace(/\s+/g, " ")),
-    extractBlock: (c) => {
-      const m = c.match(/export\s+default\s+[\s\S]+?;\s*$/m) ?? c.match(/export\s+default\s+[\s\S]+?(?=\s*\n\s*\n|$)/s);
-      return m?.[0]?.trim() ?? null;
-    },
-  },
-];
-
-/** Applica i pattern add-if-missing: aggiunge blocchi dal template solo se mancano. Univoco per tutti i file. */
-function applyAddIfMissing(userOrMerged: string, templateContent: string): string {
-  let result = userOrMerged;
-  for (const p of ADD_IF_MISSING_PATTERNS) {
-    const block = p.extractBlock(templateContent);
-    if (block && !p.hasSignature(result)) {
-      const trimmed = result.trimEnd();
-      const sep = trimmed.endsWith("\n") || !trimmed ? "" : "\n\n";
-      result = trimmed + sep + block;
-    }
-  }
-  return result;
-}
-
-/** Merge per file con pattern fn({...}) - config(), defineConfig(), ecc. Additivo: non sovrascrive. */
-export function mergeCodeObject(userContent: string, templateContent: string, _path: string): { merged: string; conflicts: Conflict[]; ext: Extracted | null } {
-  const conflicts: Conflict[] = [];
-  const userExt = extractObjectArg(userContent);
-  const templateExt = extractObjectArg(templateContent);
-  if (!templateExt) {
-    const base = userContent || templateContent;
-    return { merged: applyAddIfMissing(base, templateContent), conflicts: [], ext: null };
-  }
-  const userObj = userExt?.obj ?? {};
-  const templateObj = templateExt.obj;
-  const mergedObj = deepMergeAdditive(userObj, templateObj, "", conflicts);
-  const base = userContent || templateContent;
-  const extToReplace = userExt ?? templateExt;
-  let merged = replaceObjectArg(base, extToReplace, mergedObj);
-  merged = applyAddIfMissing(merged, templateContent);
-  return { merged, conflicts, ext: templateExt };
+/** Merge 3-way per file di codice (tipo Git). Base = template precedente (da cache). */
+function merge3Way(
+  userContent: string,
+  templateContent: string,
+  baseContent: string | undefined
+): { merged: string; hasConflicts: boolean } {
+  if (!userContent.trim()) return { merged: templateContent, hasConflicts: false };
+  const base = baseContent ?? templateContent;
+  const { conflict, result } = diff3Merge(userContent, base, templateContent, {
+    stringSeparator: LINE_SEP,
+    excludeFalseConflicts: true,
+  });
+  return { merged: result.join("\n"), hasConflicts: conflict };
 }
 
 /** Chiede all'utente se applicare i valori del template in conflitto */
@@ -203,15 +104,16 @@ export async function resolveConflicts(conflicts: Conflict[], path: string): Pro
   return overrides;
 }
 
-/** Merge generico: sceglie strategia in base al file */
+/** Merge generico: JSON additivo, code/altri merge 3-way (tipo Git) */
 export async function mergeFile(
   userContent: string | null,
   templateContent: string,
   relPath: string,
-  promptConflict: (path: string, conflicts: Conflict[]) => Promise<Record<string, unknown>>
+  promptConflict: (path: string, conflicts: Conflict[]) => Promise<Record<string, unknown>>,
+  options?: Merge3WayOptions
 ): Promise<string> {
   const isJson = relPath.toLowerCase().endsWith(".json");
-  const isCode = /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(relPath);
+  const use3Way = /\.(ts|tsx|js|jsx|mjs|cjs|html|css|md|vue|svelte)$/.test(relPath);
 
   if (isJson) {
     const { merged, conflicts } = mergeJson(userContent ?? "{}", templateContent, relPath);
@@ -224,20 +126,21 @@ export async function mergeFile(
     return merged;
   }
 
-  if (isCode) {
-    const { merged, conflicts, ext } = mergeCodeObject(userContent ?? "", templateContent, relPath);
-    if (conflicts.length > 0 && ext) {
-      const overrides = await promptConflict(relPath, conflicts);
-      const extCur = extractObjectArg(merged);
-      if (extCur) {
-        const obj = { ...extCur.obj, ...overrides };
-        return replaceObjectArg(merged, extCur, obj);
-      }
+  if (use3Way) {
+    const { merged, hasConflicts } = merge3Way(
+      userContent ?? "",
+      templateContent,
+      options?.baseContent
+    );
+    if (hasConflicts) {
+      console.warn(`\n[flow-os] Conflitti in ${relPath} - risolvi i marker <<<<<<< / >>>>>>>`);
     }
+    options?.saveBase?.(templateContent);
     return merged;
   }
 
-  // Altri file (html, css, md, ecc.): stesso sistema add-if-missing univoco
-  const base = userContent ?? templateContent;
-  return applyAddIfMissing(base, templateContent);
+  // Altri file: merge 3-way se possibile
+  const { merged } = merge3Way(userContent ?? "", templateContent, options?.baseContent);
+  options?.saveBase?.(templateContent);
+  return merged;
 }

package/src/init/scaffold.ts

@@ -1,8 +1,8 @@
-import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "fs";
 import { join, basename, dirname } from "path";
 import { fileURLToPath } from "url";
 import { pkgRoot, flowDeps, toPkgName, toShortName } from "./lib";
-import { mergeFile, resolveConflicts, mergeJsonTemplates, mergeCodeTemplates } from "./merge";
+import { mergeFile, resolveConflicts, mergeJsonTemplates, mergeCodeTemplates, type Merge3WayOptions } from "./merge";
 
 const SKIP = new Set(["node_modules", ".git", ".vite", "package.json"]);
 const NPM_REGISTRY = "https://registry.npmjs.org";
@@ -48,12 +48,33 @@ function mergeTemplateInto(combined: Map<string, string>, pkgFiles: Map<string,
   }
 }
 
-/** Scrive combined template in cwd facendo merge con file utente (un solo pass) */
+const INIT_BASE_FILE = ".flow-os/init-base.json";
+
+function loadInitBase(cwd: string): Record<string, string> {
+  const p = join(cwd, INIT_BASE_FILE);
+  if (!existsSync(p)) return {};
+  try {
+    return JSON.parse(readFileSync(p, "utf-8")) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+function saveInitBase(cwd: string, base: Record<string, string>): void {
+  const dir = join(cwd, ".flow-os");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(cwd, INIT_BASE_FILE), JSON.stringify(base, null, 2));
+}
+
+/** Scrive combined template in cwd facendo merge con file utente (merge 3-way tipo Git) */
 async function writeMergedWithUser(
   combined: Map<string, string>,
   cwd: string,
   promptConflict: (path: string, conflicts: import("./merge").Conflict[]) => Promise<Record<string, unknown>>
 ): Promise<void> {
+  const baseCache = loadInitBase(cwd);
+  const newBase: Record<string, string> = {};
+
   for (const [relPath, templateContent] of combined) {
     const dest = join(cwd, relPath);
     const destDir = dirname(dest);
@@ -62,9 +83,19 @@ async function writeMergedWithUser(
       mkdirSync(destDir, { recursive: true });
     }
     const userContent = existsSync(dest) ? readFileSync(dest, "utf-8") : null;
-    const merged = await mergeFile(userContent, templateContent, relPath, promptConflict);
+    const mergeOpts: Merge3WayOptions = {
+      baseContent: baseCache[relPath],
+      saveBase: (content) => {
+        newBase[relPath] = content;
+      },
+    };
+    const merged = await mergeFile(userContent, templateContent, relPath, promptConflict, mergeOpts);
     writeFileSync(dest, merged);
   }
+
+  if (Object.keys(newBase).length > 0) {
+    saveInitBase(cwd, { ...baseCache, ...newBase });
+  }
 }
 
 /** Indica se create-flow-os è in modalità dev (flow-os@dev) */