create-flow-os 0.0.26 → 0.0.28

package/package.json

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

package/src/init/index.ts

@@ -5,34 +5,9 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { libsWithConfig, toShortName, toPkgName } from "./lib";
 import { initLib, fetchFlowPackageVersions } from "./scaffold";
+import { box, withLoading, colors } from "./ui";
 
-// ───────────────────────────────────────────────────────────────────────────────
-// Usage: bun create flow-os i [lib...] | bun create flow-os i (prompt interattivo)
-// ───────────────────────────────────────────────────────────────────────────────
-
-// ───────────────────────────────────────────────────────────────────────────────
-// ANSI: violet (ok), yellow (unrecognized), red (error/failure)
-// ───────────────────────────────────────────────────────────────────────────────
-const V = "\x1b[95m";
-const Y = "\x1b[38;5;226m";
-const E = "\x1b[91m";
-const R = "\x1b[0m";
-const B = "\x1b[1m";
-
-// Icone: ◆ ok, ? unrecognized, ✕ failure
-
-// ───────────────────────────────────────────────────────────────────────────────
-// Box: contorno colorato, padding, strip ANSI per calcolo larghezza
-// ───────────────────────────────────────────────────────────────────────────────
-const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "").replace(/\n/g, "");
-const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - strip(s).length));
-const box = (lines: string[], color: string, w = 52) => {
-  const c = color;
-  const top = c + "╭" + "─".repeat(w) + "╮" + R;
-  const bottom = c + "╰" + "─".repeat(w) + "╯" + R;
-  const body = lines.map((l) => c + "│" + R + " ".repeat(2) + pad(l, w - 2) + c + "│" + R).join("\n");
-  return "\n" + top + "\n" + body + "\n" + bottom + "\n";
-};
+const { V, Y, E, R, B } = colors;
 
 // ───────────────────────────────────────────────────────────────────────────────
 // Args: libs da argv o prompt interattivo
@@ -62,19 +37,19 @@ if (!toInit.length) {
 }
 
 // ───────────────────────────────────────────────────────────────────────────────
-// Execute: fetch versioni pacchetti da npm (latest/dev), init libs, poi output box
+// Execute: init con loading UI elegante
 // ───────────────────────────────────────────────────────────────────────────────
 const pkgNames = toInit.map(toPkgName);
-process.stdout.write(V + "Fetching latest @flow-os/* packages..." + R);
-const versions = await fetchFlowPackageVersions(pkgNames);
-process.stdout.write(versions.size ? ` ${V}${versions.size} pkg${R}\n` : " (fallback)\n");
-await initLib(toInit, cwd, versions);
+await withLoading(async (onStep) => {
+  const versions = await fetchFlowPackageVersions(pkgNames);
+  await initLib(toInit, cwd, versions, onStep);
+});
 
 const iconOk = V + "◆" + R;
 const iconUnrec = Y + "?" + R;
 const iconFail = E + "✕" + R;
 const out: string[] = [];
-out.push(box([B + "Initialized:" + R, ...toInit.map((l) => iconOk + " " + V + l + R)], V));
+out.push(box([B + "Initialized:" + R, ...toInit.map((l) => iconOk + " " + V + l + R), "", Y + "Per versione fresca: bun create flow-os@latest" + R], V));
 if (skipped.length) out.push(box([B + "Unrecognized:" + R, ...skipped.map((l) => iconUnrec + " " + Y + l + R)], Y));
 console.log(out.join(""));
 

package/src/init/scaffold.ts

@@ -7,6 +7,13 @@ import { mergeFile, resolveConflicts, mergeJsonTemplates, mergeCodeTemplates } f
 const SKIP = new Set(["node_modules", ".git", ".vite", "package.json"]);
 const NPM_REGISTRY = "https://registry.npmjs.org";
 
+/** Cache versioni registry: 5 min TTL */
+const versionCache = new Map<string, { v: string; ts: number }>();
+const VERSION_TTL_MS = 5 * 60 * 1000;
+
+/** Cache tarball estratti: riusa se esiste e < 1h */
+const TARBALL_CACHE_MAX_AGE_MS = 60 * 60 * 1000;
+
 /** Raccoglie file da configDir in una Map relPath -> content */
 function collectConfigFiles(configDir: string, relPath = ""): Map<string, string> {
   const out = new Map<string, string>();
@@ -72,17 +79,22 @@ function isCreateFlowOsDev(): boolean {
   }
 }
 
-/** Recupera versione di un pacchetto @flow-os/* dal registry npm (latest o dev) */
+/** Recupera versione di un pacchetto @flow-os/* dal registry npm (con cache 5 min) */
 async function fetchFlowPackageVersion(pkgName: string): Promise<string | undefined> {
   const tag = isCreateFlowOsDev() ? "dev" : "latest";
+  const key = `${pkgName}@${tag}`;
+  const cached = versionCache.get(key);
+  if (cached && Date.now() - cached.ts < VERSION_TTL_MS) return cached.v;
+
   try {
-    const res = await fetch(`${NPM_REGISTRY}/${pkgName}?t=${Date.now()}`, {
-      cache: "no-store",
-      headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
+    const res = await fetch(`${NPM_REGISTRY}/${pkgName}`, {
+      headers: { "Cache-Control": "max-age=300", Accept: "application/json" },
     });
     if (!res.ok) return undefined;
     const data = (await res.json()) as { "dist-tags"?: Record<string, string> };
-    return data["dist-tags"]?.[tag] ?? data["dist-tags"]?.["latest"];
+    const v = data["dist-tags"]?.[tag] ?? data["dist-tags"]?.["latest"];
+    if (v) versionCache.set(key, { v, ts: Date.now() });
+    return v;
   } catch {
     return undefined;
   }
@@ -105,24 +117,50 @@ export async function fetchFlowClientVersion(): Promise<string | undefined> {
   return fetchFlowPackageVersion("@flow-os/client");
 }
 
-/** Scarica config da npm per qualsiasi @flow-os/* (bypass cache) */
+/** Scarica config da npm; riusa cache se estratta di recente (< 1h) */
 async function fetchConfigFromNpm(
   pkgName: string,
-  version: string
+  version: string,
+  tmpDirs: string[]
 ): Promise<{ files: Map<string, string>; configDir: string; tmpDir: string } | null> {
   const shortName = pkgName.replace(/^@flow-os\//, "");
+  const { tmpdir } = await import("os");
+  const cacheDir = join(tmpdir(), "flow-os-cache", `${shortName}-${version}`);
+  const configDir = join(cacheDir, "package", "config");
+
+  if (existsSync(configDir)) {
+    try {
+      const { statSync } = await import("fs");
+      const st = statSync(configDir);
+      if (Date.now() - st.mtimeMs < TARBALL_CACHE_MAX_AGE_MS) {
+        const files = collectConfigFiles(configDir);
+        return { files, configDir, tmpDir: cacheDir };
+      }
+    } catch {}
+  }
+
   const url = `${NPM_REGISTRY}/${pkgName}/-/${shortName}-${version}.tgz`;
   try {
-    const res = await fetch(url, { cache: "no-store" });
+    const res = await fetch(url, { headers: { "Cache-Control": "max-age=3600" } });
     if (!res.ok) return null;
     const archive = new Bun.Archive(await res.blob());
-    const { tmpdir } = await import("os");
     const tmpDir = join(tmpdir(), `flow-os-${shortName}-${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 };
+    const extractedConfigDir = join(tmpDir, "package", "config");
+    if (!existsSync(extractedConfigDir)) return null;
+    const files = collectConfigFiles(extractedConfigDir);
+
+    try {
+      const { mkdirSync } = await import("fs");
+      mkdirSync(join(cacheDir, "package"), { recursive: true });
+      const { cpSync } = await import("fs");
+      cpSync(join(tmpDir, "package", "config"), join(cacheDir, "package", "config"), {
+        recursive: true,
+      });
+    } catch {}
+
+    tmpDirs.push(tmpDir);
+    return { files, configDir: extractedConfigDir, tmpDir };
   } catch {
     return null;
   }
@@ -234,11 +272,10 @@ async function collectAllTemplates(
     let configDirForPkg: string;
     const npmVer = versionsFromNpm.get(pkgName);
     if (npmVer) {
-      const fetched = await fetchConfigFromNpm(pkgName, npmVer);
+      const fetched = await fetchConfigFromNpm(pkgName, npmVer, tmpDirs);
       if (fetched) {
         pkgFiles = fetched.files;
         configDirForPkg = fetched.configDir;
-        tmpDirs.push(fetched.tmpDir);
         const subDeps = flowDepsFromPkg(join(configDirForPkg, ".."));
         await ensureVersions(versionsFromNpm, subDeps);
         for (const sub of subDeps) {
@@ -272,17 +309,23 @@ async function collectAllTemplates(
   }
 }
 
-/** Init: 1) fetch versioni npm per tutti i pacchetti, 2) merge template in memoria, 3) mergePkg, 4) merge con file utente */
+export type InitProgressStep = "fetch" | "templates" | "write";
+
+/** Init: 1) fetch versioni npm, 2) merge template, 3) mergePkg, 4) merge con file utente */
 export async function initLib(
   libs: string[],
   cwd: string,
-  versionsFromNpm?: Map<string, string>
+  versionsFromNpm?: Map<string, string>,
+  onProgress?: (step: InitProgressStep) => void
 ): Promise<void> {
   const pkgNames = libs.map(toPkgName);
   const versions = versionsFromNpm ?? new Map<string, string>();
+
+  onProgress?.("fetch");
   const fetched = await fetchFlowPackageVersions(pkgNames);
   for (const [k, v] of fetched) versions.set(k, v);
 
+  onProgress?.("templates");
   const combined = new Map<string, string>();
   const done = new Set<string>();
   const order: string[] = [];
@@ -293,6 +336,7 @@ export async function initLib(
     mergePkg(configDir, cwd, versions);
   }
 
+  onProgress?.("write");
   await writeMergedWithUser(combined, cwd, (path, conflicts) => resolveConflicts(conflicts, path));
 
   const { rmSync } = await import("fs");

package/src/init/ui.ts

@@ -0,0 +1,76 @@
+/**
+ * UI per init: loading spinner e box coerenti con flow-os
+ */
+
+const V = "\x1b[95m";
+const Y = "\x1b[38;5;226m";
+const E = "\x1b[91m";
+const R = "\x1b[0m";
+const B = "\x1b[1m";
+const DIM = "\x1b[2m";
+
+const FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").replace(/\n/g, "");
+}
+
+export function pad(s: string, w: number): string {
+  return s + " ".repeat(Math.max(0, w - stripAnsi(s).length));
+}
+
+export function box(lines: string[], color: string, w = 52): string {
+  const c = color;
+  const top = c + "╭" + "─".repeat(w) + "╮" + R;
+  const bottom = c + "╰" + "─".repeat(w) + "╯" + R;
+  const body = lines.map((l) => c + "│" + R + "  " + pad(l, w - 2) + c + "│" + R).join("\n");
+  return "\n" + top + "\n" + body + "\n" + bottom + "\n";
+}
+
+import type { InitProgressStep } from "./scaffold";
+
+const STEP_LABELS: Record<InitProgressStep, string> = {
+  fetch: "Fetching packages",
+  templates: "Preparing templates",
+  write: "Writing files",
+};
+
+/** Esegue fn mostrando uno spinner elegante; onStep viene chiamato per aggiornare lo step */
+export async function withLoading<T>(
+  fn: (onStep: (step: InitProgressStep) => void) => Promise<T>
+): Promise<T> {
+  let step: InitProgressStep = "fetch";
+  let frame = 0;
+  const hideCursor = "\x1b[?25l";
+  const showCursor = "\x1b[?25h";
+
+  const render = () => {
+    const spin = V + FRAMES[frame % FRAMES.length] + R;
+    const msg = DIM + STEP_LABELS[step] + R;
+    const line = `  ${spin}  ${msg}`;
+    process.stdout.write("\x1b[2K\r" + line);
+  };
+
+  process.stdout.write(hideCursor);
+  const interval = setInterval(() => {
+    frame++;
+    render();
+  }, 80);
+
+  const onStep = (s: InitProgressStep) => {
+    step = s;
+  };
+
+  try {
+    const result = await fn(onStep);
+    clearInterval(interval);
+    process.stdout.write("\x1b[2K\r" + showCursor);
+    return result;
+  } catch (e) {
+    clearInterval(interval);
+    process.stdout.write("\x1b[2K\r" + showCursor);
+    throw e;
+  }
+}
+
+export const colors = { V, Y, E, R, B, DIM };