@object-ui/cli 17.5.0 → 17.6.0

package/dist/{chunk-2MZA766D.js → chunk-AP2INOE7.js}

@@ -1,9 +1,9 @@
 // src/commands/serve.ts
-import { createServer } from "vite";
+import { createServer, createLogger } from "vite";
 import react from "@vitejs/plugin-react";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3, resolve, relative } from "path";
-import chalk2 from "chalk";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import chalk3 from "chalk";
 import { execSync } from "child_process";
 
 // src/utils/app-generator.ts
@@ -142,7 +142,7 @@ function buildRoutedAppDependencies() {
     react: REACT_RANGE,
     "react-dom": REACT_RANGE,
     "react-router-dom": "^7.18.2",
-    "lucide-react": "^1.29.0",
+    "lucide-react": "^1.31.0",
     ...Object.fromEntries(PLATFORM_RUNTIME_PACKAGES.map((name) => [name, range]))
   };
 }
@@ -778,66 +778,304 @@ export default App;`;
   return files;
 }
 
-// src/commands/serve.ts
-async function serve(schemaPath, options) {
-  const cwd = process.cwd();
-  const pagesDir = join3(cwd, "pages");
-  const hasPagesDir = existsSync3(pagesDir);
-  let routes = [];
-  let schema = null;
-  let useFileSystemRouting = false;
-  if (hasPagesDir) {
-    console.log(chalk2.blue("\u{1F4C1} Detected pages/ directory - using file-system routing"));
-    routes = scanPagesDirectory(pagesDir);
-    useFileSystemRouting = true;
-    if (routes.length === 0) {
-      throw new Error("No schema files found in pages/ directory");
-    }
-    console.log(chalk2.green(`\u2713 Found ${routes.length} route(s)`));
-    routes.forEach((route) => {
-      console.log(chalk2.dim(`  ${route.path} \u2192 ${relative(cwd, route.filePath)}`));
-    });
-  } else {
-    const fullSchemaPath = resolve(cwd, schemaPath);
-    if (!existsSync3(fullSchemaPath)) {
-      throw new Error(`Schema file not found: ${schemaPath}
-Run 'objectui init' to create a sample schema.`);
+// src/utils/project-source.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { basename, dirname as dirname3, join as join3, relative, resolve } from "path";
+import chalk2 from "chalk";
+function readAppConfig(path, warnings) {
+  try {
+    return parseSchemaFile(path);
+  } catch (error) {
+    warnings.push(
+      `Failed to parse app config ${path}: ${error instanceof Error ? error.message : error}`
+    );
+    return null;
+  }
+}
+function resolveProjectSource(cwd, schemaArg) {
+  const warnings = [];
+  const absoluteSchemaPath = resolve(cwd, schemaArg);
+  if (existsSync3(absoluteSchemaPath)) {
+    const argumentStats = statSync2(absoluteSchemaPath);
+    if (argumentStats.isFile()) {
+      const projectRoot = dirname3(absoluteSchemaPath);
+      const pagesDir = join3(projectRoot, "pages");
+      if (existsSync3(pagesDir)) {
+        return {
+          mode: "routes",
+          projectRoot,
+          pagesDir,
+          pagesDirOrigin: "schema-dir",
+          routes: scanRoutes(pagesDir),
+          appConfig: readAppConfig(absoluteSchemaPath, warnings),
+          appConfigPath: absoluteSchemaPath,
+          warnings
+        };
+      }
+    } else if (argumentStats.isDirectory()) {
+      const fromDirectory = resolveDirectoryArgument(absoluteSchemaPath, warnings);
+      if (fromDirectory) return fromDirectory;
     }
-    console.log(chalk2.blue("\u{1F4CB} Loading schema:"), chalk2.cyan(schemaPath));
+  }
+  const localPagesDir = join3(cwd, "pages");
+  if (existsSync3(localPagesDir)) {
+    const localAppConfigPath = join3(cwd, "app.json");
+    const hasLocalAppConfig = existsSync3(localAppConfigPath);
+    return {
+      mode: "routes",
+      projectRoot: cwd,
+      pagesDir: localPagesDir,
+      pagesDirOrigin: "cwd",
+      routes: scanRoutes(localPagesDir),
+      appConfig: hasLocalAppConfig ? readAppConfig(localAppConfigPath, warnings) : null,
+      appConfigPath: hasLocalAppConfig ? localAppConfigPath : null,
+      warnings
+    };
+  }
+  if (!existsSync3(absoluteSchemaPath)) {
+    throw new Error(
+      `Schema file not found: ${schemaArg}
+Run 'objectui init' to create a sample schema.`
+    );
+  }
+  if (statSync2(absoluteSchemaPath).isDirectory()) {
+    throw new Error(
+      `Not a project directory: ${schemaArg}
+A directory argument must be a 'pages' directory, or contain one, for file-system routing \u2014 ${absoluteSchemaPath} is neither.
+Pass a JSON/YAML schema file instead, or run 'objectui init' to create a project.`
+    );
+  }
+  let schema;
+  try {
+    schema = parseSchemaFile(absoluteSchemaPath);
+  } catch (error) {
+    throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
+  }
+  return {
+    mode: "schema",
+    projectRoot: dirname3(absoluteSchemaPath),
+    schemaFile: absoluteSchemaPath,
+    schema,
+    warnings
+  };
+}
+function resolveDirectoryArgument(argumentDir, warnings) {
+  const isPagesDir = basename(argumentDir) === "pages";
+  const pagesDir = isPagesDir ? argumentDir : join3(argumentDir, "pages");
+  if (!isPagesDir && !(existsSync3(pagesDir) && statSync2(pagesDir).isDirectory())) {
+    return null;
+  }
+  const projectRoot = isPagesDir ? dirname3(argumentDir) : argumentDir;
+  const appConfigPath = join3(projectRoot, "app.json");
+  const hasAppConfig = existsSync3(appConfigPath) && statSync2(appConfigPath).isFile();
+  return {
+    mode: "routes",
+    projectRoot,
+    pagesDir,
+    pagesDirOrigin: "argument-dir",
+    routes: scanRoutes(pagesDir),
+    appConfig: hasAppConfig ? readAppConfig(appConfigPath, warnings) : null,
+    appConfigPath: hasAppConfig ? appConfigPath : null,
+    warnings
+  };
+}
+function scanRoutes(pagesDir) {
+  const routes = scanPagesDirectory(pagesDir);
+  if (routes.length === 0) {
+    throw new Error(`No schema files found in ${pagesDir}`);
+  }
+  return routes;
+}
+function reportProjectSource(source, cwd) {
+  for (const warning of source.warnings) {
+    console.warn(chalk2.yellow(`\u26A0 ${warning}`));
+  }
+  if (source.mode === "schema") {
+    console.log(chalk2.blue("\u{1F4CB} Loading schema:"), chalk2.cyan(relative(cwd, source.schemaFile) || source.schemaFile));
+    return;
+  }
+  console.log(chalk2.blue(`\u{1F4C2} Detected project structure at ${source.projectRoot}`));
+  if (source.appConfigPath && source.appConfig) {
+    console.log(chalk2.blue(`\u2699\uFE0F  Loaded App Config from ${relative(cwd, source.appConfigPath) || source.appConfigPath}`));
+  }
+  console.log(chalk2.blue(`\u{1F4C1} Using file-system routing from ${source.pagesDir}`));
+  console.log(chalk2.green(`\u2713 Found ${source.routes.length} route(s)`));
+  for (const route of source.routes) {
+    console.log(chalk2.dim(`  ${route.path} \u2192 ${relative(cwd, route.filePath)}`));
+  }
+}
+
+// src/utils/workspace-vite.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync3, unlinkSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname4, join as join4 } from "path";
+import { globSync } from "glob";
+import { load as loadYaml } from "js-yaml";
+var PLATFORM_SCOPE = "@object-ui/";
+var BARREL_EXTENSIONS = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx"];
+function isWorkspaceRoot(cwd) {
+  return existsSync4(join4(cwd, "pnpm-workspace.yaml"));
+}
+function workspacePatterns(cwd) {
+  const manifestPath = join4(cwd, "pnpm-workspace.yaml");
+  if (!existsSync4(manifestPath)) return [];
+  const parsed = loadYaml(readFileSync3(manifestPath, "utf-8"));
+  const patterns = parsed?.packages;
+  if (!Array.isArray(patterns)) return [];
+  return patterns.filter((p) => typeof p === "string");
+}
+function workspacePackageDirs(cwd) {
+  const patterns = workspacePatterns(cwd);
+  const include = patterns.filter((p) => !p.startsWith("!"));
+  const exclude = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  if (include.length === 0) return [];
+  const matches = globSync(include, {
+    cwd,
+    absolute: true,
+    ignore: ["**/node_modules/**", ...exclude]
+  });
+  return matches.filter((dir) => existsSync4(join4(dir, "package.json")) && statSync3(dir).isDirectory()).sort();
+}
+function findSourceBarrel(srcDir) {
+  for (const ext of BARREL_EXTENSIONS) {
+    const candidate = join4(srcDir, `index${ext}`);
+    if (existsSync4(candidate)) return candidate;
+  }
+  return void 0;
+}
+function workspaceSourceAliases(cwd) {
+  const aliases = {};
+  for (const dir of workspacePackageDirs(cwd)) {
+    let name;
     try {
-      schema = parseSchemaFile(fullSchemaPath);
-    } catch (error) {
-      throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
+      name = JSON.parse(readFileSync3(join4(dir, "package.json"), "utf-8")).name;
+    } catch {
+      continue;
     }
+    if (typeof name !== "string" || !name.startsWith(PLATFORM_SCOPE)) continue;
+    const srcDir = join4(dir, "src");
+    if (!existsSync4(srcDir) || !findSourceBarrel(srcDir)) continue;
+    aliases[name] = srcDir;
+  }
+  return aliases;
+}
+function resolveLucideAlias(cwd) {
+  const require2 = createRequire(join4(cwd, "package.json"));
+  try {
+    return dirname4(require2.resolve("lucide-react/package.json", { paths: [join4(cwd, "packages/components")] }));
+  } catch {
+    return void 0;
+  }
+}
+async function loadTempAppPostcssPlugins() {
+  try {
+    const [tailwindPostcss, autoprefixer] = await Promise.all([
+      import("@tailwindcss/postcss"),
+      import("autoprefixer")
+    ]);
+    return [tailwindPostcss.default(), autoprefixer.default()];
+  } catch (error) {
+    throw new Error(
+      `Failed to load the Tailwind CSS PostCSS pipeline: ${error instanceof Error ? error.message : error}
+  Both '@tailwindcss/postcss' and 'autoprefixer' are dependencies of @object-ui/cli \u2014 a
+  broken install of the CLI is the likeliest cause; reinstall it and try again.
+  (Refusing to start unstyled: that failure is silent in the browser.)`
+    );
+  }
+}
+async function prepareWorkspaceTempApp(cwd, tmpDir) {
+  const postcssPath = join4(tmpDir, "postcss.config.js");
+  if (existsSync4(postcssPath)) {
+    unlinkSync(postcssPath);
+  }
+  const alias = { ...workspaceSourceAliases(cwd) };
+  const lucide = resolveLucideAlias(cwd);
+  if (lucide) {
+    alias["lucide-react"] = lucide;
   }
-  const tmpDir = join3(cwd, ".objectui-tmp");
+  return {
+    resolve: { alias },
+    css: { postcss: { plugins: await loadTempAppPostcssPlugins() } }
+  };
+}
+
+// src/commands/serve.ts
+function resolveServeOpenOption(open) {
+  return open !== false;
+}
+var BROWSER_OPEN_SPAWN_ENOENT = /^Error: spawn (\S+) ENOENT/;
+function createServeLogger(base) {
+  return {
+    info: (msg, opts) => base.info(msg, opts),
+    warn: (msg, opts) => base.warn(msg, opts),
+    warnOnce: (msg, opts) => base.warnOnce(msg, opts),
+    error(msg, opts) {
+      const match = BROWSER_OPEN_SPAWN_ENOENT.exec(msg);
+      if (match) {
+        const [, command] = match;
+        console.log(
+          chalk3.dim(
+            `  (could not open the browser automatically \u2014 '${command}' is not available in this environment; open the URL above manually)`
+          )
+        );
+        return;
+      }
+      base.error(msg, opts);
+    },
+    clearScreen: (type) => base.clearScreen(type),
+    hasErrorLogged: (error) => base.hasErrorLogged(error),
+    get hasWarned() {
+      return base.hasWarned;
+    }
+  };
+}
+async function serve(schemaPath, options) {
+  const cwd = process.cwd();
+  const source = resolveProjectSource(cwd, schemaPath);
+  reportProjectSource(source, cwd);
+  const tmpDir = join5(cwd, ".objectui-tmp");
   mkdirSync2(tmpDir, { recursive: true });
-  if (useFileSystemRouting) {
-    createTempAppWithRouting(tmpDir, routes);
+  if (source.mode === "routes") {
+    createTempAppWithRouting(tmpDir, source.routes, source.appConfig);
   } else {
-    createTempApp(tmpDir, schema);
+    createTempApp(tmpDir, source.schema);
   }
-  console.log(chalk2.blue("\u{1F4E6} Installing dependencies..."));
-  console.log(chalk2.dim("  This may take a moment on first run..."));
-  try {
-    execSync("npm install --silent --prefer-offline", {
-      cwd: tmpDir,
-      stdio: "inherit"
-    });
-    console.log(chalk2.green("\u2713 Dependencies installed"));
-  } catch {
-    throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+  const isMonorepo = isWorkspaceRoot(cwd);
+  if (isMonorepo) {
+    console.log(chalk3.blue("\u{1F4E6} Detected monorepo - using root node_modules"));
+  } else {
+    console.log(chalk3.blue("\u{1F4E6} Installing dependencies..."));
+    console.log(chalk3.dim("  This may take a moment on first run..."));
+    try {
+      execSync("npm install --silent --prefer-offline", {
+        cwd: tmpDir,
+        stdio: "inherit"
+      });
+      console.log(chalk3.green("\u2713 Dependencies installed"));
+    } catch {
+      throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+    }
+  }
+  console.log(chalk3.green("\u2713 Schema loaded successfully"));
+  console.log(chalk3.blue("\u{1F680} Starting development server...\n"));
+  if (isMonorepo) {
+    console.log(chalk3.blue("\u{1F4E6} Detected monorepo - configuring workspace aliases"));
   }
-  console.log(chalk2.green("\u2713 Schema loaded successfully"));
-  console.log(chalk2.blue("\u{1F680} Starting development server...\n"));
+  const workspaceConfig = isMonorepo ? await prepareWorkspaceTempApp(cwd, tmpDir) : {};
   const viteConfig = {
     root: tmpDir,
     server: {
       port: parseInt(options.port),
       host: options.host,
-      open: true
+      open: resolveServeOpenOption(options.open),
+      fs: {
+        // Allow serving the workspace sources the aliases point at
+        allow: [cwd]
+      }
     },
-    plugins: [react()]
+    plugins: [react()],
+    customLogger: createServeLogger(createLogger()),
+    ...workspaceConfig
   };
   const server = await createServer(viteConfig);
   await server.listen();
@@ -845,18 +1083,18 @@ Run 'objectui init' to create a sample schema.`);
   const protocol = server.config.server.https ? "https" : "http";
   const displayHost = host === "0.0.0.0" ? "localhost" : host;
   console.log();
-  console.log(chalk2.green("\u2713 Server started successfully!"));
+  console.log(chalk3.green("\u2713 Server started successfully!"));
   console.log();
-  console.log(chalk2.bold("  Local:   ") + chalk2.cyan(`${protocol}://${displayHost}:${port}`));
+  console.log(chalk3.bold("  Local:   ") + chalk3.cyan(`${protocol}://${displayHost}:${port}`));
   console.log();
-  console.log(chalk2.dim("  Press Ctrl+C to stop the server"));
+  console.log(chalk3.dim("  Press Ctrl+C to stop the server"));
   console.log();
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import chalk3 from "chalk";
+import { existsSync as existsSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname5, join as join6 } from "path";
+import chalk4 from "chalk";
 var templates = {
   simple: {
     type: "div",
@@ -1370,46 +1608,48 @@ export default function App() {
 }
 async function init(name, options) {
   const cwd = process.cwd();
-  const projectDir = join4(cwd, name);
-  if (existsSync4(projectDir) && name !== ".") {
+  const projectDir = join6(cwd, name);
+  if (existsSync5(projectDir) && name !== ".") {
     throw new Error(`Directory "${name}" already exists. Please choose a different name.`);
   }
   const targetDir = name === "." ? cwd : projectDir;
   if (name !== ".") {
     mkdirSync3(projectDir, { recursive: true });
   }
-  console.log(chalk3.blue("\u{1F3A8} Creating Object UI application..."));
-  console.log(chalk3.dim(`   Template: ${options.template}`));
+  console.log(chalk4.blue("\u{1F3A8} Creating Object UI application..."));
+  console.log(chalk4.dim(`   Template: ${options.template}`));
   console.log();
   for (const [relativePath, contents] of Object.entries(
     buildInitFiles(name, options.template)
   )) {
-    const target = join4(targetDir, relativePath);
-    mkdirSync3(dirname3(target), { recursive: true });
+    const target = join6(targetDir, relativePath);
+    mkdirSync3(dirname5(target), { recursive: true });
     writeFileSync2(target, contents);
-    console.log(chalk3.green(`\u2713 Created ${relativePath}`));
+    console.log(chalk4.green(`\u2713 Created ${relativePath}`));
   }
   console.log();
-  console.log(chalk3.green("\u2728 Application created successfully!"));
+  console.log(chalk4.green("\u2728 Application created successfully!"));
   console.log();
-  console.log(chalk3.bold("Next steps:"));
+  console.log(chalk4.bold("Next steps:"));
   console.log();
   if (name !== ".") {
-    console.log(chalk3.cyan(`  cd ${name}`));
+    console.log(chalk4.cyan(`  cd ${name}`));
   }
-  console.log(chalk3.cyan("  npm install"));
-  console.log(chalk3.cyan("  npm run dev"));
+  console.log(chalk4.cyan("  npm install"));
+  console.log(chalk4.cyan("  npm run dev"));
   console.log();
-  console.log(chalk3.dim("  The development server will start on http://localhost:3000"));
+  console.log(chalk4.dim("  The development server will start on http://localhost:3000"));
   console.log();
 }
 
 export {
-  parseSchemaFile,
-  scanPagesDirectory,
   createTempApp,
   createTempAppWithRouting,
+  resolveProjectSource,
+  reportProjectSource,
+  isWorkspaceRoot,
+  prepareWorkspaceTempApp,
   serve,
   init
 };
-//# sourceMappingURL=chunk-2MZA766D.js.map
+//# sourceMappingURL=chunk-AP2INOE7.js.map