@bagelink/workspace 1.7.4 → 1.7.8

package/dist/shared/workspace.COhZ__uF.mjs

@@ -0,0 +1,973 @@
+import { writeFileSync, existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import prompts from 'prompts';
+
+function generateNetlifyRedirect(config) {
+  const redirect = `[[redirects]]
+  from = "${config.proxy}/*"
+  to = "${config.host}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfig(config, additionalConfig) {
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig) {
+  const content = generateNetlifyConfig(config, additionalConfig);
+  const resolvedPath = resolve(outPath);
+  writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+}
+function setBuildEnvVars(config) {
+  process.env.BGL_PROXY_PATH = config.proxy;
+  process.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+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'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		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: "generateNetlify",
+      message: "Generate netlify.toml for deployment?",
+      initial: true
+    }
+  ]);
+  if (setupResponse.updatePackageJson) {
+    updatePackageJsonScripts(root);
+  }
+  if (setupResponse.updateViteConfig) {
+    updateViteConfig(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 generateWorkspaceConfigSync(projectId, root = process.cwd(), configFile = "bgl.config.ts", customHost) {
+  const productionHost = customHost ?? `https://${projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		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 ${configPath}`);
+}
+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 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 workspace configuration.");
+    console.log("    See: https://github.com/bageldb/bagelink/tree/master/packages/workspace#readme");
+    return;
+  }
+  const viteConfigContent = `import { defineConfig } from 'vite'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+// https://vitejs.dev/config/
+export default defineConfig(({ mode }) => {
+	const config = workspace(mode as 'localhost' | 'development' | 'production')
+
+	return {
+		server: {
+			proxy: createViteProxy(config),
+		},
+	}
+})
+`;
+  writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+  console.log("\u2705 Created vite.config.ts");
+}
+
+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: "installDeps",
+      message: "Install dependencies?",
+      initial: true
+    }
+  ]);
+  if (!response || !response.configs) {
+    console.log("\n\u274C Setup cancelled.\n");
+    process.exit(1);
+  }
+  const { configs, installDeps } = response;
+  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");
+}
+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 { 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");
+    const indexPath = resolve(outputPath, "index.ts");
+    writeFileSync(
+      indexPath,
+      "export * from './api'\nexport * from './types.d'\n"
+    );
+    console.log("\u2705 Generated index.ts");
+    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 it in your code:`);
+    console.log(`  import { api } from '${outputDir.replace("./src/", "./")}'`);
+    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 projects...\n");
+  const fs = await import('node:fs');
+  const items = fs.readdirSync(root, { withFileTypes: true });
+  const projects = items.filter(
+    (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== ".git" && !item.name.startsWith(".")
+  ).map((item) => item.name);
+  if (projects.length === 0) {
+    console.log("No projects found in workspace");
+    return;
+  }
+  const response = await prompts({
+    type: "multiselect",
+    name: "selectedProjects",
+    message: "Select projects to generate SDK for:",
+    choices: projects.map((p) => ({ title: p, value: p, selected: true }))
+  });
+  if (!response || !response.selectedProjects || response.selectedProjects.length === 0) {
+    console.log("\n\u274C No projects selected.\n");
+    return;
+  }
+  for (const project of response.selectedProjects) {
+    console.log(`
+\u{1F4E6} Generating SDK for: ${project}`);
+    const projectPath = resolve(root, project);
+    try {
+      await generateSDK(projectPath);
+    } catch {
+      console.error(`Failed to generate SDK for ${project}`);
+    }
+  }
+  console.log("\n\u2705 All SDKs generated!");
+}
+
+async function initWorkspace(root = process.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts([
+    {
+      type: "text",
+      name: "workspaceName",
+      message: "Workspace name:",
+      initial: "my-workspace"
+    },
+    {
+      type: "text",
+      name: "projectId",
+      message: "Bagel project ID:",
+      initial: "my-project"
+    },
+    {
+      type: "confirm",
+      name: "createFirstProject",
+      message: "Create first project?",
+      initial: true
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "firstProjectName",
+      message: "First project name:",
+      initial: "web"
+    }
+  ]);
+  if (!response || !response.workspaceName) {
+    console.log("\n\u274C Workspace creation cancelled.\n");
+    process.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  const workspaceDir = resolve(root, workspaceName);
+  createWorkspaceRoot(root, workspaceName, projectId);
+  createSharedPackage(workspaceDir);
+  if (createFirstProject && firstProjectName) {
+    await addProject(firstProjectName, workspaceDir);
+  }
+  console.log("\n\u2705 Workspace created successfully!");
+  console.log("\nNext steps:");
+  console.log(`  cd ${workspaceName}`);
+  console.log("  bun install");
+  if (createFirstProject) {
+    console.log(`  bun run dev:${firstProjectName}`);
+  } else {
+    console.log("  bgl add <project-name>  # Add a project");
+  }
+  console.log("");
+}
+function createWorkspaceRoot(root, name, projectId) {
+  const workspaceDir = resolve(root, name);
+  if (existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process.exit(1);
+  }
+  mkdirSync(workspaceDir, { recursive: true });
+  const packageJson = {
+    name,
+    private: true,
+    workspaces: ["*", "!node_modules"],
+    scripts: {
+      dev: "bun scripts/dev.ts",
+      "dev:verbose": "bun run --filter './[!shared]*' dev",
+      build: "bun run --filter './[!shared]*' build",
+      typecheck: "tsc --noEmit"
+    },
+    devDependencies: {
+      "@bagelink/workspace": "latest",
+      "typescript": "^5.0.0",
+      "vite": "latest"
+    }
+  };
+  writeFileSync(
+    resolve(workspaceDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfig = `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+	production: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+})
+`;
+  writeFileSync(resolve(workspaceDir, "bgl.config.ts"), bglConfig);
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      module: "ESNext",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      noEmit: true,
+      jsx: "preserve",
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      baseUrl: ".",
+      paths: {
+        "shared/*": ["./shared/*"]
+      }
+    }
+  };
+  writeFileSync(
+    resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  writeFileSync(resolve(workspaceDir, ".gitignore"), gitignore);
+  const scriptsDir = resolve(workspaceDir, "scripts");
+  mkdirSync(scriptsDir, { recursive: true });
+  const devRunnerContent = `#!/usr/bin/env bun
+import { spawn } from 'bun'
+import { readdir } from 'fs/promises'
+import { resolve } from 'path'
+
+const projectsRoot = process.cwd()
+const projects = (await readdir(projectsRoot, { withFileTypes: true }))
+	.filter(
+		item =>
+			item.isDirectory()
+			&& item.name !== 'node_modules'
+			&& item.name !== 'shared'
+			&& item.name !== 'scripts'
+			&& item.name !== '.git'
+			&& !item.name.startsWith('.'),
+	)
+	.map(item => item.name)
+
+console.log(\`\\n\u{1F680} Starting \${projects.length} project\${projects.length > 1 ? 's' : ''}...\\n\`)
+
+const urlPattern = /Local:\\s+(http:\\/\\/localhost:\\d+)/
+
+projects.forEach((project) => {
+	const proc = spawn({
+		cmd: ['bun', 'run', 'dev'],
+		cwd: resolve(projectsRoot, project),
+		stdout: 'pipe',
+		stderr: 'pipe',
+	})
+
+	const decoder = new TextDecoder()
+
+	proc.stdout.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				const match = text.match(urlPattern)
+				if (match) {
+					console.log(\`  \u2713 \${project.padEnd(15)} \u2192 \${match[1]}\`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(\`  \u2717 \${project}: \${text.trim()}\`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\\n\u{1F4A1} Press Ctrl+C to stop all servers\\n')
+
+process.on('SIGINT', () => {
+	console.log('\\n\\n\u{1F44B} Stopping all servers...\\n')
+	process.exit()
+})
+`;
+  writeFileSync(resolve(scriptsDir, "dev.ts"), devRunnerContent);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = resolve(root, "shared");
+  mkdirSync(sharedDir, { recursive: true });
+  const packageJson = {
+    name: "shared",
+    version: "1.0.0",
+    type: "module",
+    exports: {
+      ".": "./index.ts",
+      "./utils": "./utils/index.ts",
+      "./types": "./types/index.ts"
+    }
+  };
+  writeFileSync(
+    resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  writeFileSync(
+    resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  mkdirSync(resolve(sharedDir, "utils"), { recursive: true });
+  writeFileSync(
+    resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  mkdirSync(resolve(sharedDir, "types"), { recursive: true });
+  writeFileSync(
+    resolve(sharedDir, "types", "index.ts"),
+    "// Shared types\nexport interface User {\n  id: string\n  name: string\n}\n"
+  );
+  console.log("\u2705 Created shared package");
+}
+async function addProject(name, root = process.cwd()) {
+  const projectDir = resolve(root, name);
+  if (existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = existsSync(resolve(root, "bgl.config.ts"));
+  const packageJson = {
+    name,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {},
+    devDependencies: {
+      "@vitejs/plugin-vue": "latest",
+      "vite": "latest",
+      "vue": "latest"
+    }
+  };
+  if (isWorkspace) {
+    packageJson.dependencies.shared = "workspace:*";
+  }
+  writeFileSync(
+    resolve(projectDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfigContent = isWorkspace ? `import { defineWorkspace } from '@bagelink/workspace'
+import rootWorkspace from '../bgl.config'
+
+export default defineWorkspace({
+	localhost: rootWorkspace('localhost'),
+	development: rootWorkspace('development'),
+	production: rootWorkspace('production'),
+})
+` : `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+	},
+	development: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+	production: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+})
+`;
+  writeFileSync(resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  const viteConfig = `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+export default defineConfig(({ mode }) => {
+	const config = workspace(mode as 'localhost' | 'development' | 'production')
+
+	return {
+		plugins: [vue()],
+		server: {
+			proxy: createViteProxy(config),
+		},
+	}
+})
+`;
+  writeFileSync(resolve(projectDir, "vite.config.ts"), viteConfig);
+  const srcDir = resolve(projectDir, "src");
+  mkdirSync(srcDir, { recursive: true });
+  const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${name}</title>
+</head>
+<body>
+	<div id="app"></div>
+	<script type="module" src="/src/main.ts"><\/script>
+</body>
+</html>
+`;
+  writeFileSync(resolve(projectDir, "index.html"), indexHtml);
+  const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`;
+  writeFileSync(resolve(srcDir, "main.ts"), mainTs);
+  const appVue = `<script setup lang="ts">
+import { ref } from 'vue'
+${isWorkspace ? "import { formatDate } from 'shared/utils'\n" : ""}
+const count = ref(0)
+<\/script>
+
+<template>
+	<div>
+		<h1>${name}</h1>
+		<button @click="count++">Count: {{ count }}</button>
+		${isWorkspace ? "<p>{{ formatDate(new Date()) }}</p>" : ""}
+	</div>
+</template>
+`;
+  writeFileSync(resolve(srcDir, "App.vue"), appVue);
+  console.log(`\u2705 Created project: ${name}`);
+  if (isWorkspace) {
+    updateWorkspaceScripts(root, name);
+  }
+  console.log("\nNext steps:");
+  console.log(`  cd ${name}`);
+  console.log("  bun install");
+  console.log("  bun run dev");
+  console.log("");
+}
+function updateWorkspaceScripts(root, projectName) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`;
+    packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`;
+    writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log(`\u2705 Added scripts: dev:${projectName}, build:${projectName}`);
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Could not update workspace scripts");
+  }
+}
+function listProjects(root = process.cwd()) {
+  try {
+    const items = readdirSync(root, { withFileTypes: true });
+    return items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== ".git" && !item.name.startsWith(".")
+    ).map((item) => item.name);
+  } catch {
+    return [];
+  }
+}
+
+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;
+  }
+}
+function getWorkspaceInfo(root = process.cwd()) {
+  const workspace = isWorkspace(root);
+  if (!workspace) {
+    return {
+      isWorkspace: false,
+      projects: [],
+      hasShared: false
+    };
+  }
+  try {
+    const items = readdirSync(root, { withFileTypes: true });
+    const projects = 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"))
+    ).map((item) => item.name);
+    const hasShared = existsSync(resolve(root, "shared"));
+    return {
+      isWorkspace: true,
+      projects,
+      hasShared
+    };
+  } catch {
+    return {
+      isWorkspace: false,
+      projects: [],
+      hasShared: false
+    };
+  }
+}
+
+export { generateNetlifyConfig as a, generateNetlifyRedirect as b, generateWorkspaceConfigSync as c, setupLint as d, generateSDK as e, generateSDKForWorkspace as f, generateWorkspaceConfig as g, addProject as h, initWorkspace as i, getWorkspaceInfo as j, isWorkspace as k, listProjects as l, setBuildEnvVars as s, writeNetlifyConfig as w };