@bagelink/workspace 1.9.0 → 1.9.2

package/README.md

@@ -57,10 +57,15 @@ Create `bgl.config.ts`:
 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',
+    proxy: '/api', // Optional: remove to skip proxy setup
     openapi_url: 'http://localhost:8000/openapi.json',
   },
   development: {
@@ -72,6 +77,11 @@ const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
     host: 'https://project.bagel.to',
     proxy: '/api',
   },
+  // Add your own custom environments
+  staging: {
+    host: 'https://staging.project.bagel.to',
+    proxy: '/api',
+  },
 }
 
 export default defineWorkspace(configs)
@@ -79,7 +89,66 @@ export default defineWorkspace(configs)
 
 ## Usage
 
-### 1. Configure Vite (`vite.config.ts`)
+### 1. Add Type Definitions
+
+Add to your project's `env.d.ts`:
+
+```typescript
+/// <reference types="@bagelink/workspace/env" />
+```
+
+This provides TypeScript types for injected environment variables.
+
+### 2. Configure Vite (`vite.config.ts`)
+
+**Recommended: Use the Vite plugin (keeps your config clean and standard)**
+
+```typescript
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import workspace from './bgl.config'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    bagelink({ workspace }),
+  ],
+})
+```
+
+The plugin automatically:
+- Configures proxy based on `bgl.config.ts`
+- Sets up `@` alias pointing to `./src`
+- Sets up `@shared` alias (in monorepos)
+- Keeps your vite.config.ts clean and extensible
+
+**Advanced: Custom options**
+
+```typescript
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import { fileURLToPath } from 'node:url'
+import workspace from './bgl.config'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    bagelink({
+      workspace,
+      config: {
+        sharedPath: '../packages/shared',
+        additionalAliases: {
+          '@utils': fileURLToPath(new URL('./src/utils', import.meta.url))
+        }
+      }
+    }),
+  ],
+})
+```
+
+**Legacy: Manual proxy setup**
 
 ```typescript
 import { defineConfig } from 'vite'
@@ -98,19 +167,104 @@ export default defineConfig(({ mode }) => {
 })
 ```
 
-### 2. Add scripts to `package.json`
+### 3. Use Configuration in Your App
+
+**Access config at runtime with `useWorkspace()`:**
+
+```typescript
+import { useWorkspace, getApiUrl } from '@bagelink/workspace'
+
+// In your app setup
+const { baseURL, proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL }) // Uses proxy if available, otherwise host
+
+// Or get full API URL
+const apiUrl = getApiUrl() // 'https://project.bagel.to/api'
+```
+
+**Vue component example:**
+
+```vue
+<script setup lang="ts">
+import { useWorkspace } from '@bagelink/workspace'
+import { createAuth } from '@bagelink/auth'
+
+const { baseURL, proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL }) // Uses proxy if available, otherwise host
+
+console.log('API Host:', host)
+console.log('Environment:', mode)
+</script>
+```
+
+**Access raw environment variables:**
+
+```typescript
+// These are injected at build time by the bagelink plugin
+const proxy = import.meta.env.VITE_BGL_PROXY        // '/api'
+const host = import.meta.env.VITE_BGL_HOST          // 'https://project.bagel.to'
+const openapi = import.meta.env.VITE_BGL_OPENAPI_URL // optional
+```
+
+### 4. Add scripts to `package.json`
 
 ```json
 {
   "scripts": {
     "dev": "vite",
     "dev:local": "vite --mode localhost",
-    "build": "vite build"
+    "dev:staging": "vite --mode staging",
+    "build": "vite build",
+    "build:staging": "vite build --mode staging"
   }
 }
 ```
 
-### 3. Generate Netlify Config
+### 5. Custom Environments
+
+You can define as many custom environments as you need. The environment name is completely flexible:
+
+```typescript
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+  localhost: {
+    host: 'http://localhost:8000',
+    proxy: '/api',
+  },
+  development: {
+    host: 'https://dev.project.bagel.to',
+    proxy: '/api',
+  },
+  staging: {
+    host: 'https://staging.project.bagel.to',
+    proxy: '/api',
+  },
+  preview: {
+    host: 'https://preview.project.bagel.to',
+    // No proxy - will use host directly
+  },
+  production: {
+    host: 'https://project.bagel.to',
+    proxy: '/api',
+  },
+}
+```
+
+Use the `--mode` flag to switch environments:
+
+```bash
+# Development
+bgl dev --mode development
+
+# Staging
+bgl dev --mode staging
+
+# Production build
+bgl build --mode production
+```
+
+**Note:** The `proxy` field is optional. If omitted, no proxy will be configured for that environment, and `baseURL` from `useWorkspace()` will return the `host` value instead.
+
+### 6. Generate Netlify Config
 
 ```typescript
 import { writeNetlifyConfig } from '@bagelink/workspace'
@@ -304,12 +458,104 @@ bgl lint init
 - `bun run format` - Format code
 - `bun run format:check` - Check formatting
 
-**For workspace:**
+**Auto-detects workspace:**
 ```bash
-bgl lint init --workspace
+# In workspace root (auto-detected)
+bgl lint init
+✓ Detected workspace mode
+# Sets up at workspace root
+
+# In single project (auto-detected)
+bgl lint init
+# Sets up in current project
+
+# Force modes:
+bgl lint init --workspace  # Force workspace mode
+bgl lint init --project    # Force single project mode
 ```
 
-Sets up linting at workspace root level for all projects.
+**Workspace detection:**
+- Checks for `workspaces` field in package.json
+- Checks for multiple project directories
+- Auto-applies best mode
+
+### SDK Generation
+
+#### `bgl sdk generate`
+
+Generate TypeScript SDK from OpenAPI specification:
+
+```bash
+bgl sdk generate
+
+? OpenAPI spec URL: › http://localhost:8000/openapi.json
+? Output directory: › ./src/api
+? Split into organized files? › Yes
+
+📡 Fetching OpenAPI spec from: http://localhost:8000/openapi.json
+📁 Output directory: ./src/api
+
+✅ Generated types.d.ts
+✅ Generated api.ts
+✅ Generated index.ts
+🔀 Splitting into organized files...
+✅ Files organized into directories
+
+✅ SDK generated successfully!
+
+Import it in your code:
+  import { api } from './api'
+```
+
+**Features:**
+- Auto-reads `openapi_url` from `bgl.config.ts`
+- Generates TypeScript types from OpenAPI schema
+- Creates type-safe API client
+- Optional file organization (split by endpoints)
+- Works with both local and remote OpenAPI specs
+
+**Auto-detects workspace:**
+```bash
+# In workspace root (auto-detected)
+bgl sdk generate
+✓ Detected workspace mode - will generate for multiple projects
+
+? Select projects to generate SDK for:
+  ✔ admin
+  ✔ customer
+  ✔ mobile
+
+# In single project (auto-detected)
+bgl sdk generate
+# Generates SDK for current project only
+
+# Force modes:
+bgl sdk generate --workspace  # Force workspace mode
+bgl sdk generate --project    # Force single project mode
+```
+
+**Smart behavior:**
+- Auto-detects workspace structure
+- Prompts for project selection in workspace mode
+- Reads `openapi_url` from each project's `bgl.config.ts`
+
+**Generated structure:**
+```
+src/api/
+├── index.ts          # Main export
+├── types.d.ts        # TypeScript types
+└── api.ts            # API client
+
+# Or with --split:
+src/api/
+├── endpoints/
+│   ├── users.ts
+│   ├── auth.ts
+│   └── data.ts
+├── types/
+│   └── index.ts
+└── index.ts
+```
 
 ### `npx bgl --help`
 
@@ -317,7 +563,42 @@ Show CLI help.
 
 ## API
 
-### `defineWorkspace(configs)`
+### Runtime Functions
+
+#### `useWorkspace()`
+
+Get workspace configuration at runtime. Config is injected as environment variables during build.
+
+```typescript
+import { useWorkspace } from '@bagelink/workspace'
+
+const { baseURL, proxy, host, openapiUrl, mode } = useWorkspace()
+```
+
+**Returns:**
+```typescript
+interface RuntimeWorkspaceConfig {
+  baseURL: string        // proxy if available, otherwise host
+  proxy?: string         // '/api' (optional)
+  host: string           // 'https://project.bagel.to'
+  openapiUrl?: string    // optional
+  mode: string           // current environment (e.g., 'localhost', 'development', 'staging')
+}
+```
+
+#### `getApiUrl()`
+
+Get the full API URL by combining host and proxy.
+
+```typescript
+import { getApiUrl } from '@bagelink/workspace'
+
+const apiUrl = getApiUrl() // 'https://project.bagel.to/api'
+```
+
+### Configuration Functions
+
+#### `defineWorkspace(configs)`
 
 Define workspace configuration for all environments.
 
@@ -356,21 +637,37 @@ const proxy = workspace.createProxy(config)
 workspace.generateNetlify(config, './netlify.toml')
 ```
 
-### `createViteProxy(config)`
+### Build-Time Functions
+
+These are available from `@bagelink/workspace/vite`:
+
+#### `createViteProxy(config)`
 
 Generate Vite proxy configuration.
 
-### `writeNetlifyConfig(config, outPath?, additionalConfig?)`
+```typescript
+import { createViteProxy } from '@bagelink/workspace/vite'
+```
+
+#### `writeNetlifyConfig(config, outPath?, additionalConfig?)`
 
 Generate and write netlify.toml file.
 
-### `setBuildEnvVars(config)`
+```typescript
+import { writeNetlifyConfig } from '@bagelink/workspace/vite'
+```
+
+#### `setBuildEnvVars(config)`
 
 Set environment variables for build process:
 - `BGL_PROXY_PATH` - Proxy path (e.g., `/api`)
 - `BGL_API_HOST` - API host URL
 - `BGL_OPENAPI_URL` - OpenAPI specification URL
 
+```typescript
+import { setBuildEnvVars } from '@bagelink/workspace/vite'
+```
+
 ## License
 
 MIT © Bagel Studio

package/bin/bgl.ts

@@ -1,23 +1,41 @@
 #!/usr/bin/env node
+import { resolve } from 'node:path'
 import process from 'node:process'
+import { runBuild } from '../src/build.js'
+import { isWorkspace } from '../src/detect.js'
+import { runDev } from '../src/dev.js'
 import { generateWorkspaceConfig } from '../src/init.js'
-import { addProject, initWorkspace, listProjects } from '../src/workspace.js'
 import { setupLint } from '../src/lint.js'
+import { generateSDK, generateSDKForWorkspace } from '../src/sdk.js'
+import { addProject, initWorkspace, listProjects } from '../src/workspace.js'
 
 const [,, command, subcommand, ...args] = process.argv
 
 async function main() {
 	if (command === 'init') {
-		const isWorkspace = args.includes('--workspace') || args.includes('-w')
-		if (isWorkspace) {
+		// Check both subcommand and args for --workspace flag
+		const createWorkspace
+			= subcommand === '--workspace'
+				|| subcommand === '-w'
+				|| args.includes('--workspace')
+				|| args.includes('-w')
+
+		// Support 'bgl init .' or 'bgl init <path>'
+		let targetPath = process.cwd()
+		if (subcommand && !subcommand.startsWith('-')) {
+			// If subcommand is not a flag, treat it as a path
+			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 // 'bgl add admin' -> subcommand is 'admin'
 		if (!projectName) {
 			console.error('Error: Project name is required')
 			console.log('Usage: bgl add <project-name>')
@@ -32,43 +50,162 @@ async function main() {
 		}
 		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)
+			// Auto-detect workspace or allow override
+			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('✓ 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') {
+			// Auto-detect workspace or allow override
+			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('✓ 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(
+			undefined,
+			subcommand,
+			args,
+		)
+		const exitCode = await runDev(filter, additionalArgs)
+		process.exit(exitCode)
+	}
+	else if (command === 'build') {
+		const { filter, additionalArgs } = parseFilterArgs(
+			undefined,
+			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: string): string {
+	// Keep glob patterns as-is, otherwise ensure ./ prefix
+	if (input.startsWith('.') || input.includes('*') || input.includes('[')) {
+		return input
+	}
+	return `./${input}`
+}
+
+function parseFilterArgs(
+	defaultFilter: string | undefined,
+	subcommandArg?: string,
+	argsList: string[] = [],
+): { filter?: string, additionalArgs: string[] } {
+	const tokens = [subcommandArg, ...argsList].filter(Boolean) as string[]
+
+	// Flags that take values
+	const flagsWithValues = new Set(['--mode', '--host', '--port'])
+
+	// Find non-flag tokens (excluding flag values)
+	const nonFlagIndexes: number[] = []
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i]
+		if (token.startsWith('-')) {
+			// If this flag takes a value, skip the next token
+			if (flagsWithValues.has(token)) {
+				i++ // Skip next token (the value)
+			}
+		} else {
+			// Not a flag and not a flag value
+			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: unknown) => {
 	console.error('Error:', error)
 	process.exit(1)