@bagelink/workspace 1.8.0 → 1.8.3

package/README.md

@@ -79,7 +79,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,7 +157,46 @@ 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 { proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL: proxy })
+
+// 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 { proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL: proxy })
+
+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
 {
@@ -110,7 +208,7 @@ export default defineConfig(({ mode }) => {
 }
 ```
 
-### 3. Generate Netlify Config
+### 5. Generate Netlify Config
 
 ```typescript
 import { writeNetlifyConfig } from '@bagelink/workspace'
@@ -268,13 +366,182 @@ bun run build
 - Third project: `http://localhost:5175`
 - etc.
 
+### Linting Setup
+
+#### `bgl lint init`
+
+Set up linting and formatting in your project:
+
+```bash
+bgl lint init
+
+? Select configurations to set up:
+  ✔ ESLint
+  ✔ Prettier
+  ✔ EditorConfig
+  ○ Git Hooks
+? Install dependencies? › Yes
+
+✅ Created eslint.config.js
+✅ Created .prettierrc
+✅ Created .prettierignore
+✅ Created .editorconfig
+✅ Updated package.json with lint scripts
+```
+
+**Creates:**
+- `eslint.config.js` - ESLint configuration (Vue 3 + TypeScript)
+- `.prettierrc` - Prettier configuration
+- `.prettierignore` - Prettier ignore patterns
+- `.editorconfig` - Editor configuration
+- `.lintstagedrc` - Lint-staged configuration (if git hooks selected)
+
+**Adds scripts:**
+- `bun run lint` - Run linter
+- `bun run lint:fix` - Fix linting issues
+- `bun run format` - Format code
+- `bun run format:check` - Check formatting
+
+**Auto-detects workspace:**
+```bash
+# 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
+```
+
+**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`
 
 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 { proxy, host, openapiUrl, mode } = useWorkspace()
+```
+
+**Returns:**
+```typescript
+interface RuntimeWorkspaceConfig {
+  proxy: string           // '/api'
+  host: string           // 'https://project.bagel.to'
+  openapiUrl?: string    // optional
+  mode: 'localhost' | 'development' | 'production'
+}
+```
+
+#### `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.
 
@@ -313,21 +580,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,22 +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 { setupLint } from '../src/lint.js'
+import { generateSDK, generateSDKForWorkspace } from '../src/sdk.js'
 import { addProject, initWorkspace, listProjects } from '../src/workspace.js'
 
-const [,, command, ...args] = process.argv
+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>')
@@ -31,27 +50,157 @@ 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') {
+			// 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 (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 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*')
+                            Additional args are passed to vite (e.g., --mode localhost)
+  bgl build [project] [...args] Build project by directory (default: all projects)
+  bgl lint init             Set up linting (auto-detects workspace)
+  bgl sdk generate          Generate SDK (auto-detects workspace)
 
 Options:
-  --help, -h           Show this help message
+  --workspace, -w           Force workspace mode
+  --project, -p             Force single project mode
+  --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)