create-flow-os 0.0.47-dev.1772043993 → 0.0.47-dev.1772047467

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-flow-os",
-  "version": "0.0.47-dev.1772043993",
+  "version": "0.0.47-dev.1772047467",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",
   "dependencies": {
@@ -13,7 +13,7 @@
     "create": "bun run src/create/index.ts",
     "dev": "flow-os dev",
     "build": "flow-os build",
-    "start": "bun run server/start.ts"
+    "start": "bun ./node_modules/@flow-os/server/src/bin.ts"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",

package/src/init/index.ts

@@ -1,12 +1,10 @@
 #!/usr/bin/env bun
-// Clear subito per nascondere resolving/installing di Bun
-process.stdout.write("\x1b[2J\x1b[H");
 
 import * as readline from "readline";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { libsWithConfig, toShortName, toPkgName } from "./lib";
-import { initLib, fetchFlowPackageVersions, shouldUseWorkspace } from "./scaffold";
+import { initLib, fetchFlowPackageVersions, shouldUseWorkspace, findFlowOsRepoRoot } from "./scaffold";
 import { bannerBox, withLoading, colors } from "./ui";
 
 const { V, V_LIGHT, Y, E, R, B } = colors;
@@ -16,7 +14,8 @@ const { V, V_LIGHT, Y, E, R, B } = colors;
 // ───────────────────────────────────────────────────────────────────────────────
 const cwd = process.cwd();
 const cliRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
-const available = libsWithConfig(cliRoot).map(toShortName);
+const flowOsRepoRoot = findFlowOsRepoRoot(cwd);
+const available = libsWithConfig(cliRoot, flowOsRepoRoot).map(toShortName);
 
 let libs = [...new Set(process.argv.slice(3))];
 

package/src/init/lib.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
@@ -21,7 +21,27 @@ export function flowDeps(root: string): string[] {
   return Object.keys(deps).filter((k) => k.startsWith(FLOW_PREFIX));
 }
 
-export function libsWithConfig(cliRoot: string): string[] {
+/** Scansiona packages/ per tutti gli @flow-os/* (con o senza config) */
+function scanPackagesDir(packagesDir: string): string[] {
+  const found: string[] = [];
+  try {
+    for (const name of readdirSync(packagesDir, { withFileTypes: true })) {
+      if (!name.isDirectory()) continue;
+      const pkgPath = join(packagesDir, name.name, "package.json");
+      if (!existsSync(pkgPath)) continue;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { name?: string };
+        if (pkg?.name?.startsWith(FLOW_PREFIX)) found.push(pkg.name);
+      } catch {}
+    }
+  } catch {}
+  return found;
+}
+
+export function libsWithConfig(cliRoot: string, flowOsRepoRoot?: string | null): string[] {
+  const packagesDir = flowOsRepoRoot ? join(flowOsRepoRoot, "packages") : join(cliRoot, "..");
+  const fromScan = scanPackagesDir(packagesDir);
+  if (fromScan.length > 0) return fromScan;
   const pkg = JSON.parse(readFileSync(join(cliRoot, "package.json"), "utf-8"));
   const deps = Object.keys(pkg.dependencies ?? {}).filter((k) => k.startsWith(FLOW_PREFIX));
   return deps.filter((name) => existsSync(join(pkgRoot(name), "config")));

package/src/init/merge.ts

@@ -136,7 +136,19 @@ export function mergeCodeTemplates(a: string, b: string): string {
   return replaceObjectArg(base, extB, merged);
 }
 
-/** Merge per file con pattern fn({...}) - config(), defineConfig(), ecc. */
+/** Estrae la riga "export default fn(...)" dal template */
+function extractExportDefault(content: string): string | null {
+  const m = content.match(/export\s+default\s+\w+\s*\([^)]*\)\s*;?/);
+  return m ? m[0].trim() : null;
+}
+
+/** True se user ha già export default (anche su righe diverse, formattazione diversa) */
+function userHasExportDefault(content: string): boolean {
+  const normalized = content.replace(/\s+/g, " ");
+  return /\bexport\s+default\b/.test(normalized);
+}
+
+/** 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);
@@ -146,7 +158,14 @@ export function mergeCodeObject(userContent: string, templateContent: string, _p
   const templateObj = templateExt.obj;
   const mergedObj = deepMergeAdditive(userObj, templateObj, "", conflicts);
   const base = userContent || templateContent;
-  const merged = replaceObjectArg(base, templateExt, mergedObj);
+  const extToReplace = userExt ?? templateExt;
+  let merged = replaceObjectArg(base, extToReplace, mergedObj);
+  const templateExport = extractExportDefault(templateContent);
+  if (templateExport && !userHasExportDefault(userContent)) {
+    const userTrimmed = merged.trimEnd();
+    const sep = userTrimmed.endsWith("\n") || !userTrimmed ? "" : "\n\n";
+    merged = userTrimmed + sep + templateExport;
+  }
   return { merged, conflicts, ext: templateExt };
 }
 

package/src/init/scaffold.ts

@@ -192,7 +192,7 @@ async function fetchConfigFromNpm(
 /** Sostituisce workspace:* e 0.0.1 con versione concreta (workspace va bene solo dentro flow-os) */
 function resolveFlowDeps(
   deps: Record<string, string> | undefined,
-  configDir: string,
+  pkgRootDir: string,
   versionsFromNpm: Map<string, string>,
   useWorkspace: boolean
 ): Record<string, string> {
@@ -204,7 +204,7 @@ function resolveFlowDeps(
     }
     return resolved;
   }
-  const ownerPkgPath = join(configDir, "..", "package.json");
+  const ownerPkgPath = join(pkgRootDir, "package.json");
   let ownerVersion: string | undefined;
   if (existsSync(ownerPkgPath)) {
     try {
@@ -235,6 +235,24 @@ function resolveFlowDeps(
   return resolved;
 }
 
+const PKG_KEY_ORDER = ["name", "version", "private", "type", "scripts", "dependencies", "devDependencies"];
+
+function sortPkgKeys(pkg: Record<string, unknown>): Record<string, unknown> {
+  const ordered: Record<string, unknown> = {};
+  for (const k of PKG_KEY_ORDER) {
+    if (k in pkg) {
+      const v = pkg[k];
+      ordered[k] = k === "scripts" && v && typeof v === "object" && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v as Record<string, string>).sort(([a], [b]) => a.localeCompare(b)))
+        : v;
+    }
+  }
+  for (const k of Object.keys(pkg).sort()) {
+    if (!(k in ordered)) ordered[k] = pkg[k];
+  }
+  return ordered;
+}
+
 function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, string>, useWorkspace: boolean): void {
   const configPkg = join(configDir, "package.json");
   if (!existsSync(configPkg)) return;
@@ -245,12 +263,75 @@ function mergePkg(configDir: string, cwd: string, versionsFromNpm: Map<string, s
     : { ...config, name: basename(cwd) || "flow-app" };
   target.dependencies = { ...target.dependencies, ...config.dependencies };
   target.devDependencies = { ...target.devDependencies, ...config.devDependencies };
-  for (const [k, v] of Object.entries(resolveFlowDeps(config.dependencies, configDir, versionsFromNpm, useWorkspace)))
+  const pkgRootDir = join(configDir, "..");
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.dependencies, pkgRootDir, versionsFromNpm, useWorkspace)))
     target.dependencies[k] = v;
-  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, configDir, versionsFromNpm, useWorkspace)))
+  for (const [k, v] of Object.entries(resolveFlowDeps(config.devDependencies, pkgRootDir, versionsFromNpm, useWorkspace)))
     target.devDependencies[k] = v;
   target.scripts = { ...target.scripts, ...config.scripts };
-  writeFileSync(targetPath, JSON.stringify(target, null, 2));
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
+}
+
+type FlowOsInit = { dependencies?: Record<string, string>; devDependencies?: Record<string, string>; scripts?: Record<string, string>; name?: string; version?: string; type?: string };
+
+/** Merge da flow-os-init: root package.json (se in repo) oppure package (npm) */
+function mergeFlowOsInit(
+  packageRoot: string,
+  pkgName: string,
+  cwd: string,
+  versionsFromNpm: Map<string, string>,
+  useWorkspace: boolean,
+  flowOsRepoRoot: string | null
+): void {
+  let init: FlowOsInit | undefined;
+  if (flowOsRepoRoot) {
+    const rootPkgPath = join(flowOsRepoRoot, "package.json");
+    if (existsSync(rootPkgPath)) {
+      try {
+        const rootPkg = JSON.parse(readFileSync(rootPkgPath, "utf-8")) as { "flow-os-init"?: Record<string, FlowOsInit> };
+        init = rootPkg["flow-os-init"]?.[pkgName];
+      } catch {}
+    }
+  }
+  if (!init) {
+    const pkgPath = join(packageRoot, "package.json");
+    if (!existsSync(pkgPath)) return;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { "flow-os-init"?: FlowOsInit };
+      init = pkg["flow-os-init"];
+    } catch {
+      return;
+    }
+  }
+  if (!init) return;
+  const targetPath = join(cwd, "package.json");
+  const target = existsSync(targetPath)
+    ? JSON.parse(readFileSync(targetPath, "utf-8"))
+    : { name: init.name ?? (basename(cwd) || "flow-app"), version: init.version ?? "0.0.1", type: init.type ?? "module" };
+  target.dependencies = { ...target.dependencies, ...init.dependencies };
+  target.devDependencies = { ...target.devDependencies, ...init.devDependencies };
+  for (const [k, v] of Object.entries(resolveFlowDeps(init.dependencies, packageRoot, versionsFromNpm, useWorkspace)))
+    target.dependencies[k] = v;
+  for (const [k, v] of Object.entries(resolveFlowDeps(init.devDependencies, packageRoot, versionsFromNpm, useWorkspace)))
+    target.devDependencies[k] = v;
+  target.scripts = { ...target.scripts, ...init.scripts };
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
+}
+
+/** Aggiunge dipendenza per pacchetti senza config (solo install) */
+function addDependencyForPackage(
+  pkgName: string,
+  cwd: string,
+  versionsFromNpm: Map<string, string>,
+  useWorkspace: boolean
+): void {
+  const targetPath = join(cwd, "package.json");
+  if (!existsSync(targetPath)) return;
+  const target = JSON.parse(readFileSync(targetPath, "utf-8"));
+  target.dependencies = target.dependencies ?? {};
+  const spec = useWorkspace ? "workspace:*" : (versionsFromNpm.get(pkgName) ? `^${versionsFromNpm.get(pkgName)}` : undefined);
+  if (spec) target.dependencies[pkgName] = spec;
+  writeFileSync(targetPath, JSON.stringify(sortPkgKeys(target), null, 2));
 }
 
 /** Assicura che versions abbia le versioni per pkgNames (fetch lazy) */
@@ -382,7 +463,42 @@ export async function initLib(
   await collectAllTemplates(libs, combined, done, order, versions, tmpDirs, flowOsRepoRoot);
 
   for (const configDir of order) {
-    mergePkg(configDir, cwd, versions, useWorkspace);
+    const packageRoot = join(configDir, "..");
+    const pkgName = (() => {
+      try {
+        const p = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8")) as { name?: string };
+        return p?.name ?? "";
+      } catch {
+        return "";
+      }
+    })();
+    if (existsSync(join(configDir, "package.json"))) {
+      mergePkg(configDir, cwd, versions, useWorkspace);
+    } else {
+      mergeFlowOsInit(packageRoot, pkgName, cwd, versions, useWorkspace, flowOsRepoRoot);
+    }
+  }
+
+  const targetPath = join(cwd, "package.json");
+  if (!existsSync(targetPath)) {
+    writeFileSync(
+      targetPath,
+      JSON.stringify(sortPkgKeys({ name: basename(cwd) || "flow-app", version: "0.0.1", private: true, type: "module" }), null, 2)
+    );
+  }
+
+  const toAdd = new Set<string>(pkgNames);
+  for (const configDir of order) {
+    const packageRoot = join(configDir, "..");
+    for (const peer of flowDepsFromPkg(packageRoot)) toAdd.add(peer);
+  }
+  for (const pkgName of pkgNames) {
+    const packageRoot = flowOsRepoRoot ? join(flowOsRepoRoot, "packages", toShortName(pkgName)) : (() => { try { return pkgRoot(pkgName); } catch { return ""; } })();
+    if (packageRoot) for (const peer of flowDepsFromPkg(packageRoot)) toAdd.add(peer);
+  }
+  await ensureVersions(versions, [...toAdd]);
+  for (const pkgName of toAdd) {
+    addDependencyForPackage(pkgName, cwd, versions, useWorkspace);
   }
 
   onProgress?.("write");
@@ -390,7 +506,7 @@ export async function initLib(
 
   onProgress?.("install");
   const installCwd = useWorkspace && flowOsRepoRoot ? flowOsRepoRoot : cwd;
-  const proc = Bun.spawn(["bun", "install"], { cwd: installCwd, stdout: "inherit", stderr: "inherit" });
+  const proc = Bun.spawn(["bun", "install"], { cwd: installCwd, stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
     throw new Error(`bun install exited with code ${exitCode}`);