@bagelink/workspace 1.9.0 → 1.9.2

package/dist/bin/bgl.mjs

@@ -1,21 +1,807 @@
 #!/usr/bin/env node
+import { resolve } from 'node:path';
 import process from 'node:process';
-import { i as initWorkspace, g as generateWorkspaceConfig, d as addProject, l as listProjects, e as setupLint } from '../shared/workspace.cX7U2RUq.mjs';
-import 'node:fs';
-import 'node:path';
-import 'prompts';
+import { spawn } from 'node:child_process';
+import { l as listProjects, w as writeNetlifyConfig, i as initWorkspace, a as addProject } from '../shared/workspace.Bc_dpzhA.mjs';
+import { existsSync, readFileSync, readdirSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import prompts from 'prompts';
+
+async function runBuild(filter, additionalArgs = []) {
+  const argsStr = additionalArgs.length > 0 ? ` -- ${additionalArgs.join(" ")}` : "";
+  const resolvedFilters = resolveFilters$1(filter);
+  if (!resolvedFilters || resolvedFilters.length === 0) return 1;
+  const filterArgs = resolvedFilters.map((f) => `--filter '${f}'`).join(" ");
+  const command = `bun run ${filterArgs} build${argsStr}`;
+  const proc = spawn(command, {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    shell: true
+  });
+  proc.on("error", (error) => {
+    console.error("Failed to start build:", error.message);
+  });
+  return new Promise((resolve, reject) => {
+    proc.on("exit", (code) => {
+      resolve(code || 0);
+    });
+    proc.on("error", reject);
+  });
+}
+function resolveFilters$1(filter) {
+  if (filter) return [filter];
+  const projects = listProjects();
+  if (projects.length === 0) {
+    console.error("No projects found");
+    return null;
+  }
+  return projects.map((p) => `./${p}`);
+}
+
+function isWorkspace(root = process.cwd()) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.workspaces !== void 0) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  try {
+    const items = readdirSync(root, { withFileTypes: true });
+    const projectDirs = items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== ".git" && !item.name.startsWith(".") && existsSync(resolve(root, item.name, "package.json"))
+    );
+    return projectDirs.length >= 2;
+  } catch {
+    return false;
+  }
+}
+
+const servers = /* @__PURE__ */ new Map();
+const projectToPort = /* @__PURE__ */ new Map();
+const seenLines = /* @__PURE__ */ new Set();
+const START_PORT = 5173;
+const colors = {
+  reset: "\x1B[0m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m"
+};
+function clearAndPrintServers() {
+  if (servers.size > 0) {
+    process.stdout.write("\x1B[2J\x1B[H");
+  }
+  console.log(`${colors.cyan}\u{1F680} Development Servers${colors.reset}
+`);
+  const sortedServers = Array.from(servers.entries()).sort((a, b) => a[1].order - b[1].order);
+  for (const [name, info] of sortedServers) {
+    const url = `http://localhost:${info.assignedPort}`;
+    if (info.status === "ready") {
+      console.log(`${colors.green}\u25CF${colors.reset} ${colors.cyan}${name}${colors.reset} ${colors.dim}\u2192${colors.reset} ${url}`);
+    } else {
+      console.log(`${colors.yellow}\u25CB${colors.reset} ${colors.dim}${name} (starting...)${colors.reset} ${colors.dim}${url}${colors.reset}`);
+    }
+  }
+  console.log("");
+}
+async function runDev(filter, additionalArgs = []) {
+  const argsStr = additionalArgs.length > 0 ? ` -- ${additionalArgs.join(" ")}` : "";
+  const resolvedFilters = resolveFilters(filter);
+  if (!resolvedFilters || resolvedFilters.length === 0) return 1;
+  const projectNames = resolvedFilters.map((f) => f.replace("./", "")).sort();
+  projectNames.forEach((name, index) => {
+    const assignedPort = START_PORT + index;
+    servers.set(name, {
+      name,
+      assignedPort,
+      status: "starting",
+      order: index
+    });
+    projectToPort.set(name, assignedPort);
+  });
+  clearAndPrintServers();
+  const filterArgs = resolvedFilters.map((f) => `--filter '${f}'`).join(" ");
+  projectNames.join(", ");
+  const command = `bun run ${filterArgs} dev${argsStr}`;
+  const proc = spawn(command, {
+    cwd: process.cwd(),
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: true
+  });
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  function processLine(line) {
+    if (!line.trim()) return;
+    if (seenLines.has(line)) return;
+    seenLines.add(line);
+    const portMatch = line.match(/Local:\s+http:\/\/localhost:(\d+)/);
+    if (portMatch) {
+      const port = Number.parseInt(portMatch[1], 10);
+      const projectInLine = line.match(/^(\w+)\s+dev:/);
+      if (projectInLine) {
+        const name = projectInLine[1];
+        const info = servers.get(name);
+        if (info && info.assignedPort === port && !info.actualPort) {
+          info.actualPort = port;
+          info.status = "ready";
+          clearAndPrintServers();
+        }
+      }
+    }
+  }
+  proc.stdout?.setEncoding("utf8");
+  proc.stderr?.setEncoding("utf8");
+  proc.stdout?.on("data", (data) => {
+    if (servers.size === 0) {
+      console.log(`${colors.dim}Receiving output...${colors.reset}`);
+    }
+    stdoutBuffer += data;
+    const lines = stdoutBuffer.split("\n");
+    stdoutBuffer = lines.pop() || "";
+    for (const line of lines) {
+      processLine(line);
+    }
+  });
+  proc.stderr?.on("data", (data) => {
+    stderrBuffer += data;
+    const lines = stderrBuffer.split("\n");
+    stderrBuffer = lines.pop() || "";
+    for (const line of lines) {
+      processLine(line);
+    }
+  });
+  proc.on("error", (error) => {
+    console.error(`${colors.red}Failed to start dev servers:${colors.reset}`, error.message);
+  });
+  process.on("SIGINT", () => {
+    proc.kill("SIGINT");
+    process.exit(0);
+  });
+  return new Promise((resolve, reject) => {
+    proc.on("exit", (code) => {
+      resolve(code || 0);
+    });
+    proc.on("error", reject);
+  });
+}
+function resolveFilters(filter) {
+  if (filter) return [filter];
+  const projects = listProjects();
+  if (projects.length === 0) {
+    console.error("No projects found");
+    return null;
+  }
+  return projects.map((p) => `./${p}`);
+}
+
+async function generateWorkspaceConfig(root = process.cwd(), configFile = "bgl.config.ts") {
+  console.log("\n\u{1F527} No bgl.config.ts found. Let's create one!\n");
+  const response = await prompts([
+    {
+      type: "text",
+      name: "projectId",
+      message: "What is your Bagel project ID?",
+      initial: "my-project",
+      validate: (value) => value.length > 0 ? true : "Project ID is required"
+    },
+    {
+      type: "confirm",
+      name: "useCustomHost",
+      message: "Use custom production host?",
+      initial: false
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "customHost",
+      message: "Enter production host URL:",
+      initial: "https://api.example.com"
+    }
+  ]);
+  if (!response || !response.projectId) {
+    console.log("\n\u274C Config generation cancelled.\n");
+    process.exit(1);
+  }
+  const productionHost = response.useCustomHost === true ? response.customHost : `https://${response.projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+/**
+ * Define your workspace environments
+ * You can add as many custom environments as needed (e.g., 'staging', 'preview')
+ * Use --mode flag to switch: bgl dev --mode <env_name>
+ */
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api', // Optional: remove to skip proxy setup
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`;
+  const configPath = resolve(root, configFile);
+  writeFileSync(configPath, configContent, "utf-8");
+  console.log(`
+\u2705 Created ${configFile}`);
+  console.log(`   Production host: ${productionHost}`);
+  console.log(`   Local dev host: http://localhost:8000
+`);
+  const setupResponse = await prompts([
+    {
+      type: "confirm",
+      name: "updatePackageJson",
+      message: "Add/update dev scripts in package.json?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "updateViteConfig",
+      message: "Create/update vite.config.ts?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "createTsConfig",
+      message: "Create tsconfig.app.json with path aliases?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "generateNetlify",
+      message: "Generate netlify.toml for deployment?",
+      initial: true
+    }
+  ]);
+  if (setupResponse.updatePackageJson) {
+    updatePackageJsonScripts(root);
+  }
+  if (setupResponse.updateViteConfig) {
+    updateViteConfig(root);
+  }
+  if (setupResponse.createTsConfig) {
+    createTsConfig(root);
+  }
+  if (setupResponse.generateNetlify) {
+    const prodConfig = {
+      host: productionHost,
+      proxy: "/api"
+    };
+    writeNetlifyConfig(prodConfig, resolve(root, "netlify.toml"));
+  }
+  console.log("\n\u{1F4A1} You can edit these files to customize your configuration.\n");
+}
+function updatePackageJsonScripts(root) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    console.log("\u26A0\uFE0F  No package.json found, skipping script update");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    const scriptsToAdd = {
+      "dev": "vite",
+      "dev:local": "vite --mode localhost",
+      "build": "vite build",
+      "preview": "vite preview"
+    };
+    let modified = false;
+    for (const [key, value] of Object.entries(scriptsToAdd)) {
+      if (key === "dev" || key === "dev:local") {
+        if (packageJson.scripts[key] !== value) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      } else {
+        if (!packageJson.scripts[key]) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf-8");
+      console.log("\u2705 Updated package.json with dev scripts");
+    } else {
+      console.log("\u2139\uFE0F  Scripts already up to date in package.json");
+    }
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+function createTsConfig(root) {
+  const tsConfigPath = resolve(root, "tsconfig.app.json");
+  const tsConfigExists = existsSync(tsConfigPath);
+  if (tsConfigExists) {
+    console.log("\u26A0\uFE0F  tsconfig.app.json already exists, skipping");
+    return;
+  }
+  const tsConfigContent = `{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@shared/*": ["../shared/*"]
+    }
+  },
+  "include": ["src/**/*", "src/**/*.vue"],
+  "exclude": ["node_modules"]
+}
+`;
+  writeFileSync(tsConfigPath, tsConfigContent, "utf-8");
+  console.log("\u2705 Created tsconfig.app.json");
+}
+function updateViteConfig(root) {
+  const viteConfigPath = resolve(root, "vite.config.ts");
+  const viteConfigExists = existsSync(viteConfigPath);
+  if (viteConfigExists) {
+    const existingConfig = readFileSync(viteConfigPath, "utf-8");
+    if (existingConfig.includes("@bagelink/workspace")) {
+      console.log("\u2139\uFE0F  vite.config.ts already configured");
+      return;
+    }
+    console.log("\u26A0\uFE0F  vite.config.ts exists. Please manually add the bagelink plugin:");
+    console.log("");
+    console.log("    import { bagelink } from '@bagelink/workspace/vite'");
+    console.log("    import workspace from './bgl.config'");
+    console.log("");
+    console.log("    plugins: [");
+    console.log("      vue(),");
+    console.log("      bagelink({ workspace }),");
+    console.log("    ]");
+    console.log("");
+    return;
+  }
+  const viteConfigContent = `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import workspace from './bgl.config'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+	plugins: [
+		vue(),
+		bagelink({ workspace }),
+	],
+})
+`;
+  writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+  console.log("\u2705 Created vite.config.ts");
+}
+
+const REDUNDANT_FILES = [
+  // Old ESLint configs
+  ".eslintrc",
+  ".eslintrc.json",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.yaml",
+  ".eslintrc.yml",
+  // Oxlint
+  "oxlint.json",
+  // Old Prettier configs (we create .prettierrc)
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs",
+  ".prettierrc.json",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  ".prettierrc.toml"
+];
+async function setupLint(root = process.cwd(), isWorkspace = false) {
+  console.log("\n\u{1F50D} Setting up linting...\n");
+  const response = await prompts([
+    {
+      type: "multiselect",
+      name: "configs",
+      message: "Select configurations to set up:",
+      choices: [
+        { title: "ESLint", value: "eslint", selected: true },
+        { title: "Prettier", value: "prettier", selected: true },
+        { title: "EditorConfig", value: "editorconfig", selected: true },
+        { title: "Git Hooks", value: "githooks", selected: false }
+      ]
+    },
+    {
+      type: "confirm",
+      name: "cleanRedundant",
+      message: "Clean up redundant lint config files?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "installDeps",
+      message: "Install dependencies?",
+      initial: true
+    }
+  ]);
+  if (!response || !response.configs) {
+    console.log("\n\u274C Setup cancelled.\n");
+    process.exit(1);
+  }
+  const { configs, cleanRedundant, installDeps } = response;
+  if (cleanRedundant) {
+    await cleanRedundantFiles(root);
+  }
+  if (configs.includes("eslint")) {
+    createEslintConfig(root, isWorkspace);
+  }
+  if (configs.includes("prettier")) {
+    createPrettierConfig(root);
+  }
+  if (configs.includes("editorconfig")) {
+    createEditorConfig(root);
+  }
+  if (configs.includes("githooks")) {
+    createGitHooks(root);
+  }
+  updatePackageJsonLint(root, configs);
+  if (installDeps) {
+    console.log("\n\u{1F4E6} Installing dependencies...");
+    console.log("Run: bun add -D @bagelink/lint-config eslint prettier typescript");
+  }
+  console.log("\n\u2705 Linting setup complete!");
+  console.log("\nAvailable commands:");
+  console.log("  bun run lint       - Run linter");
+  console.log("  bun run lint:fix   - Fix linting issues");
+  console.log("  bun run format     - Format code with Prettier");
+  console.log("");
+}
+function createEslintConfig(root, isWorkspace) {
+  const configPath = resolve(root, "eslint.config.js");
+  const config = isWorkspace ? `import { defineConfig } from '@bagelink/lint-config/eslint'
+
+export default defineConfig({
+	// Workspace-level ESLint config
+	ignores: ['**/dist/**', '**/node_modules/**', '**/.bun-cache/**'],
+})
+` : `import vue3Config from '@bagelink/lint-config/eslint/vue3'
+
+export default vue3Config
+`;
+  writeFileSync(configPath, config);
+  console.log("\u2705 Created eslint.config.js");
+}
+function createPrettierConfig(root) {
+  const configPath = resolve(root, ".prettierrc");
+  const config = {
+    semi: false,
+    singleQuote: true,
+    tabWidth: 2,
+    useTabs: true,
+    trailingComma: "all",
+    printWidth: 100,
+    arrowParens: "avoid"
+  };
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  console.log("\u2705 Created .prettierrc");
+  const ignorePath = resolve(root, ".prettierignore");
+  const ignore = `dist
+node_modules
+.bun-cache
+*.min.js
+*.min.css
+`;
+  writeFileSync(ignorePath, ignore);
+  console.log("\u2705 Created .prettierignore");
+}
+function createEditorConfig(root) {
+  const configPath = resolve(root, ".editorconfig");
+  const config = `root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{json,yml,yaml}]
+indent_style = space
+indent_size = 2
+`;
+  writeFileSync(configPath, config);
+  console.log("\u2705 Created .editorconfig");
+}
+function createGitHooks(root) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found, skipping git hooks");
+    return;
+  }
+  const lintStagedConfig = {
+    "*.{js,jsx,ts,tsx,vue}": ["eslint --fix"],
+    "*.{json,md,yml,yaml}": ["prettier --write"]
+  };
+  writeFileSync(
+    resolve(root, ".lintstagedrc"),
+    `${JSON.stringify(lintStagedConfig, null, 2)}
+`
+  );
+  console.log("\u2705 Created .lintstagedrc");
+  console.log("\u2139\uFE0F  Add simple-git-hooks and lint-staged to devDependencies");
+  console.log("   Then run: npx simple-git-hooks");
+}
+async function cleanRedundantFiles(root) {
+  const foundFiles = [];
+  for (const file of REDUNDANT_FILES) {
+    const filePath = resolve(root, file);
+    if (existsSync(filePath)) {
+      foundFiles.push(file);
+    }
+  }
+  if (foundFiles.length === 0) {
+    console.log("\u2728 No redundant files found");
+    return;
+  }
+  console.log("\n\u{1F4CB} Found redundant files:");
+  foundFiles.forEach((file) => {
+    console.log(`   - ${file}`);
+  });
+  const confirmResponse = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: `Delete ${foundFiles.length} redundant file${foundFiles.length > 1 ? "s" : ""}?`,
+    initial: true
+  });
+  if (!confirmResponse.confirm) {
+    console.log("\u23ED\uFE0F  Skipped cleaning redundant files");
+    return;
+  }
+  let deleted = 0;
+  for (const file of foundFiles) {
+    try {
+      unlinkSync(resolve(root, file));
+      console.log(`\u{1F5D1}\uFE0F  Deleted ${file}`);
+      deleted++;
+    } catch (error) {
+      console.error(`\u274C Failed to delete ${file}:`, error);
+    }
+  }
+  console.log(`\u2705 Cleaned up ${deleted} file${deleted > 1 ? "s" : ""}`);
+}
+function updatePackageJsonLint(root, configs) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (configs.includes("eslint")) {
+      if (!packageJson.scripts.lint) {
+        packageJson.scripts.lint = "eslint .";
+      }
+      if (!packageJson.scripts["lint:fix"]) {
+        packageJson.scripts["lint:fix"] = "eslint . --fix";
+      }
+    }
+    if (configs.includes("prettier")) {
+      if (!packageJson.scripts.format) {
+        packageJson.scripts.format = "prettier --write .";
+      }
+      if (!packageJson.scripts["format:check"]) {
+        packageJson.scripts["format:check"] = "prettier --check .";
+      }
+    }
+    writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log("\u2705 Updated package.json with lint scripts");
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+
+async function generateSDK(root = process.cwd()) {
+  console.log("\n\u{1F527} Generating SDK from OpenAPI...\n");
+  let config = null;
+  let openApiUrl;
+  try {
+    const configPath = resolve(root, "bgl.config.ts");
+    if (existsSync(configPath)) {
+      const module = await import(`file://${configPath}`);
+      const workspace = module.default;
+      if (typeof workspace === "function") {
+        config = workspace("development");
+        if (config?.openapi_url) {
+          openApiUrl = config.openapi_url;
+        }
+      }
+    }
+  } catch {
+  }
+  const response = await prompts([
+    {
+      type: openApiUrl !== void 0 ? null : "text",
+      name: "openApiUrl",
+      message: "OpenAPI spec URL:",
+      initial: openApiUrl ?? "http://localhost:8000/openapi.json"
+    },
+    {
+      type: "text",
+      name: "outputDir",
+      message: "Output directory:",
+      initial: "./src/api"
+    },
+    {
+      type: "confirm",
+      name: "splitFiles",
+      message: "Split into organized files?",
+      initial: true
+    }
+  ]);
+  if (!response) {
+    console.log("\n\u274C SDK generation cancelled.\n");
+    process.exit(1);
+  }
+  const finalUrl = openApiUrl ?? response.openApiUrl;
+  const { outputDir, splitFiles } = response;
+  console.log(`
+\u{1F4E1} Fetching OpenAPI spec from: ${finalUrl}`);
+  console.log(`\u{1F4C1} Output directory: ${outputDir}
+`);
+  try {
+    const { openAPI } = await import('@bagelink/sdk');
+    const { readFileSync } = await import('node:fs');
+    const { dirname, join } = await import('node:path');
+    const { fileURLToPath } = await import('node:url');
+    const { types, code } = await openAPI(finalUrl, "/api");
+    const outputPath = resolve(root, outputDir);
+    if (!existsSync(outputPath)) {
+      mkdirSync(outputPath, { recursive: true });
+    }
+    const typesPath = resolve(outputPath, "types.d.ts");
+    writeFileSync(typesPath, types);
+    console.log("\u2705 Generated types.d.ts");
+    const apiPath = resolve(outputPath, "api.ts");
+    writeFileSync(apiPath, code);
+    console.log("\u2705 Generated api.ts");
+    console.log("\u2139\uFE0F  Stream utilities are imported from @bagelink/sdk");
+    if (splitFiles) {
+      console.log("\n\u{1F500} Splitting into organized files...");
+      console.log("\u2139\uFE0F  File splitting requires @bagelink/sdk bin scripts");
+      console.log("    Keeping monolithic structure for now");
+    }
+    console.log("\n\u2705 SDK generated successfully!");
+    console.log(`
+Import directly in your code:`);
+    console.log(`  import { agents } from '${outputDir.replace("./src/", "./")}/api'`);
+    console.log(`  import type { SendMessageRequest } from '${outputDir.replace("./src/", "./")}/types.d'`);
+    console.log("");
+  } catch (error) {
+    console.error("\n\u274C Failed to generate SDK:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
+    console.log("\nMake sure:");
+    console.log("  1. @bagelink/sdk is installed: bun add -D @bagelink/sdk");
+    console.log("  2. OpenAPI URL is accessible");
+    console.log("  3. API server is running (if using localhost)");
+    process.exit(1);
+  }
+}
+async function generateSDKForWorkspace(root = process.cwd()) {
+  console.log("\n\u{1F3E2} Generating SDK for workspace...\n");
+  let config = null;
+  let openApiUrl;
+  try {
+    const configPath = resolve(root, "bgl.config.ts");
+    if (existsSync(configPath)) {
+      const module = await import(`file://${configPath}`);
+      const workspace = module.default;
+      if (typeof workspace === "function") {
+        config = workspace("development");
+        if (config?.openapi_url) {
+          openApiUrl = config.openapi_url;
+        }
+      }
+    }
+  } catch {
+  }
+  const response = await prompts({
+    type: openApiUrl !== void 0 ? null : "text",
+    name: "openApiUrl",
+    message: "OpenAPI spec URL:",
+    initial: openApiUrl ?? "http://localhost:8000/openapi.json"
+  });
+  if (response === void 0 || openApiUrl === void 0 && !response.openApiUrl) {
+    console.log("\n\u274C SDK generation cancelled.\n");
+    process.exit(1);
+  }
+  const finalUrl = openApiUrl ?? response.openApiUrl;
+  const outputDir = "./shared";
+  console.log(`
+\u{1F4E1} Fetching OpenAPI spec from: ${finalUrl}`);
+  console.log(`\u{1F4C1} Output directory: ${outputDir}
+`);
+  try {
+    const { openAPI } = await import('@bagelink/sdk');
+    const { types, code } = await openAPI(finalUrl, "/api");
+    const outputPath = resolve(root, outputDir);
+    if (!existsSync(outputPath)) {
+      mkdirSync(outputPath, { recursive: true });
+    }
+    const typesPath = resolve(outputPath, "types.d.ts");
+    writeFileSync(typesPath, types);
+    console.log("\u2705 Generated types.d.ts");
+    const apiPath = resolve(outputPath, "api.ts");
+    writeFileSync(apiPath, code);
+    console.log("\u2705 Generated api.ts");
+    console.log("\n\u2705 SDK generated successfully in shared folder!");
+    console.log(`
+Import from shared in your projects:`);
+    console.log(`  import { agents } from '../shared/api'`);
+    console.log(`  import type { SendMessageRequest } from '../shared/types'`);
+    console.log("");
+  } catch (error) {
+    console.error("\n\u274C Failed to generate SDK:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
+    console.log("\nMake sure:");
+    console.log("  1. @bagelink/sdk is installed: bun add -D @bagelink/sdk");
+    console.log("  2. OpenAPI URL is accessible");
+    console.log("  3. API server is running (if using localhost)");
+    process.exit(1);
+  }
+}
 
 const [, , command, subcommand, ...args] = process.argv;
 async function main() {
   if (command === "init") {
-    const isWorkspace = args.includes("--workspace") || args.includes("-w");
-    if (isWorkspace) {
+    const createWorkspace = subcommand === "--workspace" || subcommand === "-w" || args.includes("--workspace") || args.includes("-w");
+    let targetPath = process.cwd();
+    if (subcommand && !subcommand.startsWith("-")) {
+      targetPath = subcommand === "." ? process.cwd() : resolve(process.cwd(), subcommand);
+    }
+    if (createWorkspace) {
       await initWorkspace();
     } else {
-      await generateWorkspaceConfig();
+      await generateWorkspaceConfig(targetPath);
     }
   } else if (command === "add") {
-    const projectName = args[0];
+    const projectName = subcommand;
     if (!projectName) {
       console.error("Error: Project name is required");
       console.log("Usage: bgl add <project-name>");
@@ -28,39 +814,128 @@ async function main() {
       console.log("No projects found");
     } else {
       console.log("\nProjects:");
-      projects.forEach((p) => console.log(`  - ${p}`));
+      projects.forEach((p) => {
+        console.log(`  - ${p}`);
+      });
       console.log("");
     }
   } else if (command === "lint") {
     if (subcommand === "init") {
-      const isWorkspace = args.includes("--workspace") || args.includes("-w");
-      await setupLint(process.cwd(), isWorkspace);
+      const forceWorkspace = args.includes("--workspace") || args.includes("-w");
+      const forceProject = args.includes("--project") || args.includes("-p");
+      let workspaceMode = isWorkspace(process.cwd());
+      if (forceWorkspace) workspaceMode = true;
+      if (forceProject) workspaceMode = false;
+      if (workspaceMode) {
+        console.log("\u2713 Detected workspace mode");
+      }
+      await setupLint(process.cwd(), workspaceMode);
     } else {
       console.log(`
 Lint Commands:
-  bgl lint init              Set up linting in current project
-  bgl lint init --workspace  Set up linting for workspace root
+  bgl lint init              Set up linting (auto-detects workspace)
+  bgl lint init --workspace  Force workspace mode
+  bgl lint init --project    Force single project mode
+`);
+      process.exit(1);
+    }
+  } else if (command === "sdk") {
+    if (subcommand === "generate") {
+      const forceWorkspace = args.includes("--workspace") || args.includes("-w");
+      const forceProject = args.includes("--project") || args.includes("-p");
+      let workspaceMode = isWorkspace(process.cwd());
+      if (forceWorkspace) workspaceMode = true;
+      if (forceProject) workspaceMode = false;
+      if (workspaceMode) {
+        console.log("\u2713 Detected workspace mode - will generate for multiple projects");
+        await generateSDKForWorkspace();
+      } else {
+        await generateSDK(process.cwd());
+      }
+    } else {
+      console.log(`
+SDK Commands:
+  bgl sdk generate             Generate SDK (auto-detects workspace)
+  bgl sdk generate --workspace Force workspace mode
+  bgl sdk generate --project   Force single project mode
 `);
       process.exit(1);
     }
+  } else if (command === "dev") {
+    const { filter, additionalArgs } = parseFilterArgs(
+      void 0,
+      subcommand,
+      args
+    );
+    const exitCode = await runDev(filter, additionalArgs);
+    process.exit(exitCode);
+  } else if (command === "build") {
+    const { filter, additionalArgs } = parseFilterArgs(
+      void 0,
+      subcommand,
+      args
+    );
+    const exitCode = await runBuild(filter, additionalArgs);
+    process.exit(exitCode);
   } else {
     console.log(`
 Bagel Workspace CLI
 
 Usage:
-  bgl init                   Generate bgl.config.ts for single project
-  bgl init --workspace       Create a new workspace with multiple projects
-  bgl add <name>             Add a new project to workspace
-  bgl list                   List all projects in workspace
-  bgl lint init              Set up linting in current project
-  bgl lint init --workspace  Set up linting for workspace root
+  bgl init [path]           Generate bgl.config.ts for single project
+                            Examples: bgl init, bgl init ., bgl init ./my-app
+  bgl init --workspace      Create a new workspace with multiple projects
+  bgl add <name>            Add a new project to workspace
+  bgl list                  List all projects in workspace
+  bgl dev [filter] [...args] Run dev servers with clean output (default: './!shared*')
+                            Examples:
+                              bgl dev --mode localhost
+                              bgl dev --mode staging
+                              bgl dev admin --mode production
+  bgl build [project] [...args] Build project by directory (default: all projects)
+                            Example: bgl build --mode production
+  bgl lint init             Set up linting (auto-detects workspace)
+  bgl sdk generate          Generate SDK (auto-detects workspace)
 
 Options:
+  --workspace, -w           Force workspace mode
+  --project, -p             Force single project mode
+  --mode <env>              Set environment (matches bgl.config.ts keys)
   --help, -h                Show this help message
+
+Note: Commands auto-detect workspace mode based on directory structure
 `);
     process.exit(command === "--help" || command === "-h" ? 0 : 1);
   }
 }
+function normalizeFilter(input) {
+  if (input.startsWith(".") || input.includes("*") || input.includes("[")) {
+    return input;
+  }
+  return `./${input}`;
+}
+function parseFilterArgs(defaultFilter, subcommandArg, argsList = []) {
+  const tokens = [subcommandArg, ...argsList].filter(Boolean);
+  const flagsWithValues = /* @__PURE__ */ new Set(["--mode", "--host", "--port"]);
+  const nonFlagIndexes = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("-")) {
+      if (flagsWithValues.has(token)) {
+        i++;
+      }
+    } else {
+      const prevToken = i > 0 ? tokens[i - 1] : null;
+      if (!prevToken || !flagsWithValues.has(prevToken)) {
+        nonFlagIndexes.push(i);
+      }
+    }
+  }
+  const filterIndex = nonFlagIndexes.length > 0 ? nonFlagIndexes[nonFlagIndexes.length - 1] : -1;
+  const filter = filterIndex >= 0 ? normalizeFilter(tokens[filterIndex]) : defaultFilter;
+  const additionalArgs = filterIndex >= 0 ? tokens.filter((_, index) => index !== filterIndex) : tokens;
+  return { filter, additionalArgs };
+}
 main().catch((error) => {
   console.error("Error:", error);
   process.exit(1);