create-flow-os 0.0.1-dev.1771614697

package/README.md

@@ -0,0 +1,4 @@
+# create-flow
+
+**Uso:** `bun create flow-os [nome-progetto]` (o `bunx create-flow-os [nome-progetto]`).  
+**Dev (framework):** da `packages/create-flow`: `bun run gen`, poi `bun run publish:dev`; crea progetti con `bun create flow-os mio-app --dev` per usare le versioni da npm@dev.

package/config.json

@@ -0,0 +1,54 @@
+{
+  "profiles": {
+    "client": {
+      "exclude": [
+        "packages",
+        "node_modules",
+        ".git",
+        ".cursor",
+        "agent-transcripts",
+        "server"
+      ]
+    },
+    "server": {
+      "exclude": [
+        "packages",
+        "node_modules",
+        ".git",
+        ".cursor",
+        "agent-transcripts",
+        "client"
+      ]
+    },
+    "full": {
+      "exclude": [
+        "packages",
+        "node_modules",
+        ".git",
+        ".cursor",
+        "agent-transcripts"
+      ]
+    }
+  },
+  "packages": {
+    "core": {
+      "package": "@flow-os/core",
+      "includeIn": [
+        "client"
+      ],
+      "deps": [
+        "@flow-os/core"
+      ]
+    },
+    "router": {
+      "package": "@flow-os/router",
+      "includeIn": [
+        "client"
+      ],
+      "deps": [
+        "@flow-os/core",
+        "@flow-os/router"
+      ]
+    }
+  }
+}

package/flow.config.client.ts

@@ -0,0 +1,3 @@
+import { config } from '@flow-os/client';
+
+export default config({});

package/gen.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+/**
+ * Scan repo: tag // @flow-package: <id> (id = chiave in config.packages). Genera profiles/, packages/.
+ * Valida includeIn in base ai path (solo client → client, solo server → server, entrambi → full) e aggiorna config.
+ * Legge import → deps. Scrive tutto in config.json (niente manifest).
+ */
+
+import { readdir, mkdir } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+import { rm } from "node:fs/promises";
+import { copyWithExclude, transformPackageJson, findPackageDir } from "./utils.ts";
+
+const CREATE_FLOW_DIR = import.meta.dir;
+const REPO_ROOT = (process.env.FLOW_FRAMEWORK_ROOT ?? join(CREATE_FLOW_DIR, "..", "..")).replace(/\\/g, "/");
+
+const TAG = /^\s*\/\/\s*@flow-package\s*:\s*(\w+)\s*$/m;
+const IMPORT_SPEC = /from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\)/g;
+const EXCLUDE = new Set(["node_modules", ".git", "dist", ".cursor", "agent-transcripts"].map((s) => s.toLowerCase()));
+const SCAN_EXT = new Set([".ts", ".tsx", ".js", ".jsx"]);
+
+type PackageEntry = { package: string; includeIn: string[]; deps?: string[] };
+type Config = { profiles: Record<string, { exclude: string[] }>; packages: Record<string, PackageEntry> };
+
+function getPackageFromHead(content: string): string | null {
+  const m = content.slice(0, 500).match(TAG);
+  return m ? m[1]! : null;
+}
+
+function stripTag(content: string): string {
+  const first = content.split(/\r?\n/)[0] ?? "";
+  if (TAG.test(first.trim())) return content.replace(/^[^\n]+\n?/, "");
+  return content;
+}
+
+function getFlowImports(content: string): string[] {
+  const out: string[] = [];
+  let m: RegExpExecArray | null;
+  IMPORT_SPEC.lastIndex = 0;
+  while ((m = IMPORT_SPEC.exec(content)) !== null) {
+    const spec = (m[1] ?? m[2])!.trim();
+    if (spec.startsWith("@flow-os/") && !out.includes(spec)) out.push(spec);
+  }
+  return out;
+}
+
+async function walk(dir: string, rel: string, filesByPkg: Record<string, string[]>) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    const name = ent.name;
+    if (EXCLUDE.has(name.toLowerCase())) continue;
+    const relPath = rel ? `${rel}/${name}` : name;
+    if (rel === "packages" && name === "create-flow") continue;
+    const full = join(dir, name);
+    if (ent.isDirectory()) {
+      await walk(full, relPath, filesByPkg);
+      continue;
+    }
+    const ext = name.replace(/^.*\./, ".");
+    if (!SCAN_EXT.has(ext)) continue;
+    const content = await Bun.file(full).text();
+    const pkg = getPackageFromHead(content);
+    if (!pkg) continue;
+    const norm = relPath.replace(/\\/g, "/");
+    if (!filesByPkg[pkg]) filesByPkg[pkg] = [];
+    if (!filesByPkg[pkg]!.includes(norm)) filesByPkg[pkg]!.push(norm);
+  }
+}
+
+async function main() {
+  const configPath = join(CREATE_FLOW_DIR, "config.json");
+  const config: Config = (await Bun.file(configPath).json()) as Config;
+
+  const filesByPkg: Record<string, string[]> = {};
+  await walk(REPO_ROOT, "", filesByPkg);
+
+  for (const pkgId of Object.keys(config.packages)) {
+    const entry = config.packages[pkgId]!;
+    const paths = filesByPkg[pkgId] ?? [];
+    const hasServer = paths.some((p) => p.startsWith("server/"));
+    const hasClient = paths.some((p) => p.startsWith("client/"));
+    let includeIn = entry.includeIn ?? [];
+    if (paths.length > 0) {
+      // Solo valori minimali: full = solo full; client/server = disponibili anche per full
+      if (hasServer && hasClient) includeIn = ["full"];
+      else if (hasServer) includeIn = ["server"];
+      else if (hasClient) includeIn = ["client"];
+      else includeIn = ["full"];
+      entry.includeIn = includeIn;
+    }
+  }
+
+  const profilesDir = join(CREATE_FLOW_DIR, "profiles");
+  const packagesDir = join(CREATE_FLOW_DIR, "packages");
+  await rm(profilesDir, { recursive: true, force: true });
+  await rm(packagesDir, { recursive: true, force: true });
+
+  const rootPkg = (await Bun.file(join(REPO_ROOT, "package.json")).json()) as { dependencies?: Record<string, string> };
+  const flowDepNames = Object.keys(rootPkg.dependencies ?? {}).filter((k) => k === "@flow-os" || k.startsWith("@flow-os/"));
+
+  for (const [id, profile] of Object.entries(config.profiles)) {
+    const dest = join(profilesDir, id);
+    await copyWithExclude(REPO_ROOT, dest, profile.exclude ?? []);
+    if (id === "client") {
+      const override = join(CREATE_FLOW_DIR, "flow.config.client.ts");
+      try {
+        await Bun.write(join(dest, "flow.config.ts"), Bun.file(override));
+      } catch {}
+    }
+    const pkgPath = join(dest, "package.json");
+    let pkg = (await Bun.file(pkgPath).json()) as Record<string, unknown>;
+    pkg = transformPackageJson(pkg, "placeholder", {}, false) as Record<string, unknown>;
+    const deps = (pkg.dependencies as Record<string, string>) ?? {};
+    const exclude = new Set((profile.exclude ?? []).map((s) => s.toLowerCase()));
+    const profilePackagesDir = join(dest, "packages");
+    await mkdir(profilePackagesDir, { recursive: true });
+    for (const pkgName of flowDepNames) {
+      if (exclude.has("server") && (pkgName === "@flow-os/server")) continue;
+      if (exclude.has("client") && (pkgName === "@flow-os/client")) continue;
+      const dir = await findPackageDir(REPO_ROOT, pkgName);
+      if (!dir) continue;
+      const folderName = basename(dir);
+      const destPkg = join(profilePackagesDir, folderName);
+      await copyWithExclude(dir, destPkg, ["node_modules", ".git", "dist"]);
+      deps[pkgName] = "file:./packages/" + folderName;
+    }
+    pkg.dependencies = deps;
+    delete (pkg as Record<string, unknown>).workspaces;
+    await Bun.write(pkgPath, JSON.stringify(pkg, null, 2));
+    console.log("profiles/" + id);
+  }
+
+  for (const pkgId of Object.keys(config.packages)) {
+    const entry = config.packages[pkgId]!;
+    const paths = filesByPkg[pkgId] ?? [];
+    const dest = join(packagesDir, pkgId);
+    await mkdir(dest, { recursive: true });
+    const depsSet = new Set<string>([entry.package]);
+    const prefix = new RegExp(`^packages/${pkgId}(/scaffold)?/`);
+    for (const rel of paths) {
+      const src = join(REPO_ROOT, rel);
+      try {
+        const content = await Bun.file(src).text();
+        for (const d of getFlowImports(content)) depsSet.add(d);
+        const destRel = rel.replace(prefix, "") || rel;
+        const destFile = join(dest, destRel);
+        await mkdir(dirname(destFile), { recursive: true });
+        await Bun.write(destFile, stripTag(content));
+      } catch (e) {
+        console.warn("Skip", rel, e);
+      }
+    }
+    entry.deps = [...depsSet].sort();
+    console.log("packages/" + pkgId);
+  }
+
+  await Bun.write(configPath, JSON.stringify(config, null, 2));
+  console.log("config.json scritto (deps aggiornati).");
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/index.ts

@@ -0,0 +1,175 @@
+#!/usr/bin/env bun
+/**
+ * create-flow: scegli profile (full/client/server) → librerie filtrate → copia profiles/ + packages/, install.
+ * Dev: REPO_ROOT disponibile → deps con file:. Prod: bun install normale.
+ */
+
+import { rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { copyWithExclude, transformPackageJson } from "./utils.ts";
+
+const argv = process.argv.slice(2);
+const noInstall = argv.includes("--no-install");
+const noGit = argv.includes("--no-git");
+const force = argv.includes("--force");
+const yes = argv.includes("--yes") || argv.includes("-y");
+const useDevTag = argv.includes("--dev");
+const nameArg = argv.find((a) => !a.startsWith("--"));
+
+const DIR = import.meta.dir;
+const REPO_ROOT = (process.env.FLOW_FRAMEWORK_ROOT ?? join(DIR, "..", "..")).replace(/\\/g, "/");
+
+type PackageEntry = { package: string; includeIn: string[]; deps?: string[] };
+type Config = { profiles: Record<string, { exclude?: string[] }>; packages: Record<string, PackageEntry> };
+
+async function main() {
+  p.intro(pc.cyan(" Flow – create project\n"));
+
+  const config: Config = (await Bun.file(join(DIR, "config.json")).json()) as Config;
+  const hasDeps = Object.values(config.packages).every((e) => Array.isArray(e.deps));
+  if (!hasDeps) {
+    p.cancel("Esegui prima " + pc.cyan("bun run gen") + " dalla cartella create-flow.");
+    process.exit(1);
+  }
+
+  const projectName = nameArg?.trim() || (yes ? "my-flow-app" : null);
+  let name = projectName;
+  if (!name && !yes) {
+    const r = await p.text({ message: "Project name", initialValue: "my-flow-app", validate: (v) => (!v?.trim() ? "Obbligatorio" : undefined) });
+    if (p.isCancel(r)) process.exit(0);
+    name = (r as string).trim() || "my-flow-app";
+  }
+  if (!name) name = "my-flow-app";
+
+  function optsForProfile(profileId: string) {
+    return Object.entries(config.packages).filter(([, e]) => {
+      const inc = e.includeIn ?? [];
+      if (inc.includes(profileId)) return true;
+      if (profileId === "full" && (inc.includes("client") || inc.includes("server"))) return true;
+      return false;
+    });
+  }
+  let profileId: string;
+  let selected: string[] = [];
+  const optsForFull = optsForProfile("full");
+
+  if (yes) {
+    profileId = "full";
+    selected = optsForFull.map(([id]) => id);
+  } else {
+    const complete = await p.select({
+      message: "Vuoi installare tutto completo? (tutti i package)",
+      options: [
+        { value: "yes", label: "Sì, tutto completo" },
+        { value: "no", label: "No, scelgo profile e package" },
+      ],
+    });
+    if (p.isCancel(complete)) process.exit(0);
+    if (complete === "yes") {
+      profileId = "full";
+      selected = optsForFull.map(([id]) => id);
+    } else {
+      const profile = await p.select({
+        message: "Client, Server o Client+Server?",
+        options: [
+          { value: "client", label: "Client" },
+          { value: "server", label: "Server" },
+          { value: "full", label: "Client + Server" },
+        ],
+      });
+      if (p.isCancel(profile)) process.exit(0);
+      profileId = profile as string;
+      const opts = optsForProfile(profileId);
+      if (opts.length > 0) {
+        const r = await p.multiselect({
+          message: "Scegli i package",
+          options: opts.map(([id]) => ({ value: id, label: id })),
+          required: false,
+        });
+        if (!p.isCancel(r)) selected = (r as string[]) ?? [];
+      }
+    }
+  }
+
+  const projectPath = join(process.cwd(), name);
+  const exists = await stat(projectPath).then(() => true).catch(() => false);
+  if (exists && !force) {
+    p.cancel("Esiste già: " + name + ". Usa " + pc.cyan("--force") + ".");
+    process.exit(1);
+  }
+  if (exists) await rm(projectPath, { recursive: true, force: true });
+
+  const profileDir = join(DIR, "profiles", profileId);
+  try {
+    await stat(profileDir);
+  } catch {
+    p.cancel("Profile " + profileId + " non trovato. Esegui " + pc.cyan("bun run gen") + ".");
+    process.exit(1);
+  }
+
+  const scaffoldSpinner = p.spinner();
+  scaffoldSpinner.start("Scaffold");
+  await copyWithExclude(profileDir, projectPath, ["node_modules", ".git"]);
+  for (const id of selected) {
+    const pkgDir = join(DIR, "packages", id);
+    try {
+      await copyWithExclude(pkgDir, projectPath, []);
+    } catch {}
+  }
+  scaffoldSpinner.stop("Scaffold");
+
+  const extraDeps: Record<string, string> = {};
+  for (const id of selected) {
+    const deps = config.packages[id]?.deps;
+    if (deps) for (const d of deps) extraDeps[d] = "^0.0.1";
+  }
+  const pkgPath = join(projectPath, "package.json");
+  const pkg = (await Bun.file(pkgPath).json()) as Record<string, unknown>;
+  await Bun.write(pkgPath, JSON.stringify(transformPackageJson(pkg, name, extraDeps, false), null, 2));
+
+  if (!noGit) {
+    try {
+      await Bun.$`git init ${projectPath}`.quiet();
+      await Bun.$`git -C ${projectPath} add -A`.quiet();
+      await Bun.$`git -C ${projectPath} commit -m "Initial commit (Flow)"`.quiet();
+    } catch {}
+  }
+
+  const finalPkg = (await Bun.file(pkgPath).json()) as { workspaces?: string[]; dependencies?: Record<string, string> };
+  delete finalPkg.workspaces;
+  if (finalPkg.dependencies) {
+    for (const k of Object.keys(finalPkg.dependencies)) {
+      if (finalPkg.dependencies[k] === "workspace:*") finalPkg.dependencies[k] = "^0.0.1";
+      if (useDevTag && (k === "@flow-os" || k.startsWith("@flow-os/"))) finalPkg.dependencies[k] = "dev";
+    }
+  }
+  await Bun.write(pkgPath, JSON.stringify(finalPkg, null, 2));
+
+  if (useDevTag) {
+    const projectPackagesDir = join(projectPath, "packages");
+    try {
+      await rm(projectPackagesDir, { recursive: true, force: true });
+    } catch {}
+  }
+
+  if (!noInstall) {
+    const s = p.spinner();
+    s.start("Install");
+    const proc = Bun.spawn(["bun", "install"], { cwd: projectPath, stdout: "pipe", stderr: "pipe" });
+    const code = await proc.exited;
+    s.stop(code === 0 ? "Install ok" : "Install failed");
+    if (code !== 0) {
+      const err = await new Response(proc.stderr).text();
+      p.log.error(err || "bun install exit " + code);
+    }
+  }
+
+  p.outro([pc.green("Ok."), "", "  " + pc.cyan("cd " + name), "  " + pc.cyan("bun run dev")].join("\n"));
+}
+
+main().catch((e) => {
+  p.log.error(String(e));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "create-flow-os",
+  "version": "0.0.1-dev.1771614697",
+  "type": "module",
+  "bin": {
+    "create-flow-os": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "utils.ts",
+    "gen.ts",
+    "config.json",
+    "flow.config.client.ts",
+    "profiles",
+    "packages"
+  ],
+  "scripts": {
+    "gen": "bun gen.ts",
+    "create": "bun index.ts",
+    "publish:dev": "bun publish-dev.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "bun-types": "~1.2.0"
+  }
+}

package/profiles/client/.dockerignore

@@ -0,0 +1,12 @@
+node_modules
+dist
+.git
+*.local
+.env
+.env.*
+*.tsbuildinfo
+.oxlintrc.json
+.oxfmtrc.json
+.cursor
+packages/style/extension/out
+*.vsix

package/profiles/client/.oxfmtrc.json

@@ -0,0 +1,7 @@
+{
+  "printWidth": 100,
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "ignorePatterns": ["node_modules/**", "dist/**", "bun.lockb", "**/node_modules/**"]
+}

package/profiles/client/.oxlintrc.json

@@ -0,0 +1,13 @@
+{
+  "ignorePatterns": [
+    "node_modules/**",
+    "dist/**",
+    "**/node_modules/**",
+    "*.config.js",
+    "*.config.ts"
+  ],
+  "rules": {
+    "unicorn/no-empty-file": "off",
+    "@typescript-eslint/triple-slash-reference": "off"
+  }
+}

package/profiles/client/.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+  "files.exclude": {
+    "index.html": true,
+    "**/node_modules": true,
+    "bun.lock": true,
+    "**/tsconfig.json": true,
+    "**/tsconfig.tsbuildinfo": true,
+    ".oxlintrc.json": true,
+    ".oxfmtrc.json": true
+  },
+  "editor.colorDecorators": true
+}

package/profiles/client/Dockerfile

@@ -0,0 +1,26 @@
+# DEV: packages/flow-os → workaround Bun workspace (doppio install).
+# PROD: install → build → start (PORT da env)
+
+FROM oven/bun:1 AS builder
+WORKDIR /app
+COPY . .
+RUN if [ -d packages ] && [ -f packages/flow-os/package.json ]; then \
+  bun install || true && bun install; \
+else \
+  bun install --frozen-lockfile; \
+fi
+RUN bun run build
+RUN mkdir -p out && cp package.json bun.lock* out/ && cp -r dist server out/ && ([ -d packages ] && cp -r packages out/ || true)
+
+FROM oven/bun:1
+WORKDIR /app
+ENV NODE_ENV=production
+ENV PORT=3000
+COPY --from=builder /app/out/ ./
+RUN if [ -d packages ] && [ -f packages/flow-os/package.json ]; then \
+  bun install --frozen-lockfile --production || true && bun install --frozen-lockfile --production; \
+else \
+  bun install --frozen-lockfile --production; \
+fi
+EXPOSE 3000
+CMD ["bun", "run", "start"]