create-flow-os 0.0.22 → 0.0.24

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "create-flow-os",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",
   "dependencies": {
-    "@flow-os/client": "^0.0.22"
+    "@flow-os/client": "^0.0.24"
   },
   "bin": {
     "create-flow-os": "./src/index.ts"

package/src/init/index.ts

@@ -67,8 +67,7 @@ if (!toInit.length) {
 process.stdout.write(V + "Fetching latest @flow-os/client..." + R);
 const clientVersion = await fetchFlowClientVersion();
 process.stdout.write(clientVersion ? ` ${V}${clientVersion}${R}\n` : " (fallback)\n");
-const done = new Set<string>();
-for (const lib of toInit) initLib(lib, cwd, done, clientVersion);
+await initLib(toInit, cwd, clientVersion);
 
 const iconOk = V + "◆" + R;
 const iconUnrec = Y + "?" + R;

package/src/init/merge.ts

@@ -0,0 +1,204 @@
+/**
+ * Merge generico per qualsiasi file: additivo (aggiunge, non toglie).
+ * In conflitto: chiede all'utente.
+ */
+
+import * as readline from "readline";
+
+export type Conflict = { key: string; userVal: unknown; templateVal: unknown; path: string };
+
+/** Deep merge di oggetti: aggiunge chiavi nuove, per esistenti chiede se diverso */
+function deepMergeAdditive(
+  user: Record<string, unknown>,
+  template: Record<string, unknown>,
+  path: string,
+  conflicts: Conflict[]
+): Record<string, unknown> {
+  const out = { ...user };
+  for (const [k, v] of Object.entries(template)) {
+    if (!(k in out)) {
+      out[k] = v;
+    } else {
+      const uv = out[k];
+      if (uv !== null && typeof uv === "object" && !Array.isArray(uv) && v !== null && typeof v === "object" && !Array.isArray(v)) {
+        out[k] = deepMergeAdditive(uv as Record<string, unknown>, v as Record<string, unknown>, `${path}.${k}`, conflicts);
+      } else if (JSON.stringify(uv) !== JSON.stringify(v)) {
+        conflicts.push({ key: k, userVal: uv, templateVal: v, path: `${path}.${k}` });
+      }
+    }
+  }
+  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 };
+  for (const [k, v] of Object.entries(b)) {
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && k in out && typeof out[k] === "object") {
+      out[k] = mergeTemplatesOnly(out[k] as Record<string, unknown>, v as Record<string, unknown>);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+/** Merge per file JSON */
+export function mergeJson(userContent: string, templateContent: string, _path: string): { merged: string; conflicts: Conflict[] } {
+  const conflicts: Conflict[] = [];
+  const user = (JSON.parse(userContent || "{}") || {}) as Record<string, unknown>;
+  const template = (JSON.parse(templateContent || "{}") || {}) as Record<string, unknown>;
+  const merged = deepMergeAdditive(user, template, "", conflicts);
+  return { merged: JSON.stringify(merged, null, 2), conflicts };
+}
+
+/** Merge template+template per JSON (sync, nessun conflitto) */
+export function mergeJsonTemplates(a: string, b: string): string {
+  const objA = (JSON.parse(a || "{}") || {}) as Record<string, unknown>;
+  const objB = (JSON.parse(b || "{}") || {}) as Record<string, unknown>;
+  return JSON.stringify(mergeTemplatesOnly(objA, objB), null, 2);
+}
+
+/** Merge template+template per code (sync, nessun conflitto) */
+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);
+}
+
+/** Merge per file con pattern fn({...}) - config(), defineConfig(), ecc. */
+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) return { merged: userContent || templateContent, conflicts: [], ext: null };
+  const userObj = userExt?.obj ?? {};
+  const templateObj = templateExt.obj;
+  const mergedObj = deepMergeAdditive(userObj, templateObj, "", conflicts);
+  const base = userContent || templateContent;
+  const merged = replaceObjectArg(base, templateExt, mergedObj);
+  return { merged, conflicts, ext: templateExt };
+}
+
+/** Chiede all'utente se applicare i valori del template in conflitto */
+export async function resolveConflicts(conflicts: Conflict[], path: string): Promise<Record<string, unknown>> {
+  if (conflicts.length === 0) return {};
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const overrides: Record<string, unknown> = {};
+  for (const c of conflicts) {
+    const msg = `\n${path}: conflitto su "${c.key}" - tuo: ${JSON.stringify(c.userVal)}, template: ${JSON.stringify(c.templateVal)}. Sovrascrivere? (s/n): `;
+    const answer = await new Promise<string>((resolve) => rl.question(msg, resolve));
+    if (answer.toLowerCase().startsWith("s") || answer.toLowerCase().startsWith("y")) {
+      overrides[c.key] = c.templateVal;
+    }
+  }
+  rl.close();
+  return overrides;
+}
+
+/** Merge generico: sceglie strategia in base al file */
+export async function mergeFile(
+  userContent: string | null,
+  templateContent: string,
+  relPath: string,
+  promptConflict: (path: string, conflicts: Conflict[]) => Promise<Record<string, unknown>>
+): Promise<string> {
+  const isJson = relPath.toLowerCase().endsWith(".json");
+  const isCode = /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(relPath);
+
+  if (isJson) {
+    const { merged, conflicts } = mergeJson(userContent ?? "{}", templateContent, relPath);
+    if (conflicts.length > 0) {
+      const overrides = await promptConflict(relPath, conflicts);
+      const obj = JSON.parse(merged) as Record<string, unknown>;
+      for (const [k, v] of Object.entries(overrides)) obj[k] = v;
+      return JSON.stringify(obj, null, 2);
+    }
+    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);
+      }
+    }
+    return merged;
+  }
+
+  return userContent ?? templateContent;
+}

package/src/init/scaffold.ts

@@ -2,14 +2,61 @@ import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync } 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";
 
 const SKIP = new Set(["node_modules", ".git", ".vite", "package.json"]);
 const NPM_REGISTRY = "https://registry.npmjs.org";
 
-function copyConfig(configDir: string, cwd: string): void {
+/** Raccoglie file da configDir in una Map relPath -> content */
+function collectConfigFiles(configDir: string, relPath = ""): Map<string, string> {
+  const out = new Map<string, string>();
   for (const e of readdirSync(configDir, { withFileTypes: true })) {
     if (SKIP.has(e.name)) continue;
-    cpSync(join(configDir, e.name), join(cwd, e.name), { recursive: e.isDirectory() });
+    const src = join(configDir, e.name);
+    const childRel = relPath ? `${relPath}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      for (const [k, v] of collectConfigFiles(src, childRel)) out.set(k, v);
+    } else {
+      out.set(childRel, readFileSync(src, "utf-8"));
+    }
+  }
+  return out;
+}
+
+/** Merge template A con template B (stesso relPath) */
+function mergeTemplateInto(combined: Map<string, string>, pkgFiles: Map<string, string>): void {
+  for (const [relPath, content] of pkgFiles) {
+    const existing = combined.get(relPath);
+    const isJson = relPath.toLowerCase().endsWith(".json");
+    const isCode = /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(relPath);
+    if (existing === undefined) {
+      combined.set(relPath, content);
+    } else if (isJson) {
+      combined.set(relPath, mergeJsonTemplates(existing, content));
+    } else if (isCode) {
+      combined.set(relPath, mergeCodeTemplates(existing, content));
+    } else {
+      combined.set(relPath, content);
+    }
+  }
+}
+
+/** Scrive combined template in cwd facendo merge con file utente (un solo pass) */
+async function writeMergedWithUser(
+  combined: Map<string, string>,
+  cwd: string,
+  promptConflict: (path: string, conflicts: import("./merge").Conflict[]) => Promise<Record<string, unknown>>
+): Promise<void> {
+  for (const [relPath, templateContent] of combined) {
+    const dest = join(cwd, relPath);
+    const destDir = dirname(dest);
+    if (!existsSync(destDir)) {
+      const { mkdirSync } = await import("fs");
+      mkdirSync(destDir, { recursive: true });
+    }
+    const userContent = existsSync(dest) ? readFileSync(dest, "utf-8") : null;
+    const merged = await mergeFile(userContent, templateContent, relPath, promptConflict);
+    writeFileSync(dest, merged);
   }
 }
 
@@ -42,6 +89,29 @@ export async function fetchFlowClientVersion(): Promise<string | undefined> {
   }
 }
 
+/** Scarica config da npm (bypass cache) - estrae in temp, ritorna { files, configDir, tmpDir } */
+async function fetchConfigFromNpm(
+  pkgName: string,
+  version: string
+): Promise<{ files: Map<string, string>; configDir: string; tmpDir: string } | null> {
+  const shortName = pkgName.replace(/^@flow-os\//, "");
+  const url = `${NPM_REGISTRY}/${pkgName}/-/${shortName}-${version}.tgz`;
+  try {
+    const res = await fetch(url, { cache: "no-store" });
+    if (!res.ok) return null;
+    const archive = new Bun.Archive(await res.blob());
+    const { tmpdir } = await import("os");
+    const tmpDir = join(tmpdir(), `flow-os-client-${version}-${Date.now()}`);
+    await archive.extract(tmpDir, { glob: ["package/config/**"] });
+    const configDir = join(tmpDir, "package", "config");
+    if (!existsSync(configDir)) return null;
+    const files = collectConfigFiles(configDir);
+    return { files, configDir, tmpDir };
+  } catch {
+    return null;
+  }
+}
+
 /** Sostituisce workspace:* e 0.0.1 con versione concreta (workspace va bene solo dentro flow-os) */
 function resolveFlowDeps(
   deps: Record<string, string> | undefined,
@@ -107,19 +177,73 @@ function mergePkg(configDir: string, cwd: string, clientVersionFromNpm: string |
   writeFileSync(targetPath, JSON.stringify(target, null, 2));
 }
 
-export function initLib(lib: string, cwd: string, done: Set<string>, clientVersionFromNpm?: string): void {
-  const pkgName = toPkgName(lib);
-  if (done.has(pkgName)) return;
+/** Fase 1: raccoglie e merge tutti i template in memoria, ritorna ordine pacchetti */
+async function collectAllTemplates(
+  libs: string[],
+  combined: Map<string, string>,
+  done: Set<string>,
+  order: string[],
+  clientVersionFromNpm: string | undefined,
+  tmpDirs: string[]
+): Promise<void> {
+  for (const lib of libs) {
+    const pkgName = toPkgName(lib);
+    if (done.has(pkgName)) continue;
+
+    const root = pkgRoot(pkgName);
+    const configDir = join(root, "config");
+    if (!existsSync(configDir) && pkgName !== "@flow-os/client") continue;
 
-  const root = pkgRoot(pkgName);
-  const configDir = join(root, "config");
-  if (!existsSync(configDir)) return;
+    for (const sub of flowDeps(root)) {
+      await collectAllTemplates([toShortName(sub)], combined, done, order, clientVersionFromNpm, tmpDirs);
+    }
 
-  for (const sub of flowDeps(root)) {
-    initLib(toShortName(sub), cwd, done, clientVersionFromNpm);
+    let pkgFiles: Map<string, string>;
+    let configDirForPkg: string;
+    if (pkgName === "@flow-os/client" && clientVersionFromNpm) {
+      const fetched = await fetchConfigFromNpm(pkgName, clientVersionFromNpm);
+      if (fetched) {
+        pkgFiles = fetched.files;
+        configDirForPkg = fetched.configDir;
+        tmpDirs.push(fetched.tmpDir);
+      } else {
+        if (!existsSync(configDir)) continue;
+        pkgFiles = collectConfigFiles(configDir);
+        configDirForPkg = configDir;
+      }
+    } else {
+      if (!existsSync(configDir)) continue;
+      pkgFiles = collectConfigFiles(configDir);
+      configDirForPkg = configDir;
+    }
+    mergeTemplateInto(combined, pkgFiles);
+    order.push(configDirForPkg);
+    done.add(pkgName);
   }
+}
 
-  copyConfig(configDir, cwd);
-  mergePkg(configDir, cwd, clientVersionFromNpm);
-  done.add(pkgName);
+/** Init: 1) merge tutti i template in memoria, 2) mergePkg per ogni lib, 3) un solo merge con file utente */
+export async function initLib(
+  libs: string[],
+  cwd: string,
+  clientVersionFromNpm?: string
+): Promise<void> {
+  const combined = new Map<string, string>();
+  const done = new Set<string>();
+  const order: string[] = [];
+  const tmpDirs: string[] = [];
+  await collectAllTemplates(libs, combined, done, order, clientVersionFromNpm, tmpDirs);
+
+  for (const configDir of order) {
+    mergePkg(configDir, cwd, clientVersionFromNpm);
+  }
+
+  await writeMergedWithUser(combined, cwd, (path, conflicts) => resolveConflicts(conflicts, path));
+
+  const { rmSync } = await import("fs");
+  for (const d of tmpDirs) {
+    try {
+      rmSync(d, { recursive: true, force: true });
+    } catch {}
+  }
 }