@bagelink/workspace 1.7.3 → 1.7.8

package/src/workspace.ts

@@ -0,0 +1,505 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Initialize a new workspace with flat structure
+ */
+export async function initWorkspace(root: string = process.cwd()): Promise<void> {
+	console.log('\n🚀 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: boolean) => (prev ? 'text' : null),
+			name: 'firstProjectName',
+			message: 'First project name:',
+			initial: 'web',
+		},
+	])
+
+	if (!response || !response.workspaceName) {
+		console.log('\n❌ Workspace creation cancelled.\n')
+		process.exit(1)
+	}
+
+	const { workspaceName, projectId, createFirstProject, firstProjectName } = response
+
+	const workspaceDir = resolve(root, workspaceName)
+
+	// Create workspace structure
+	createWorkspaceRoot(root, workspaceName, projectId)
+
+	// Create shared package
+	createSharedPackage(workspaceDir)
+
+	if (createFirstProject && firstProjectName) {
+		await addProject(firstProjectName, workspaceDir)
+	}
+
+	console.log('\n✅ 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('')
+}
+
+/**
+ * Create workspace root files
+ */
+function createWorkspaceRoot(root: string, name: string, projectId: string): void {
+	const workspaceDir = resolve(root, name)
+
+	if (existsSync(workspaceDir)) {
+		console.error(`❌ Directory ${name} already exists`)
+		process.exit(1)
+	}
+
+	mkdirSync(workspaceDir, { recursive: true })
+
+	// package.json
+	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)}\n`,
+	)
+
+	// bgl.config.ts (shared)
+	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)
+
+	// tsconfig.json
+	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)}\n`,
+	)
+
+	// .gitignore
+	const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`
+
+	writeFileSync(resolve(workspaceDir, '.gitignore'), gitignore)
+
+	// Create scripts directory
+	const scriptsDir = resolve(workspaceDir, 'scripts')
+	mkdirSync(scriptsDir, { recursive: true })
+
+	// Copy dev runner script
+	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🚀 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(\`  ✓ \${project.padEnd(15)} → \${match[1]}\`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(\`  ✗ \${project}: \${text.trim()}\`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\\n💡 Press Ctrl+C to stop all servers\\n')
+
+process.on('SIGINT', () => {
+	console.log('\\n\\n👋 Stopping all servers...\\n')
+	process.exit()
+})
+`
+
+	writeFileSync(resolve(scriptsDir, 'dev.ts'), devRunnerContent)
+
+	console.log(`✅ Created workspace: ${name}`)
+}
+
+/**
+ * Create shared package
+ */
+function createSharedPackage(root: string): void {
+	const sharedDir = resolve(root, 'shared')
+	mkdirSync(sharedDir, { recursive: true })
+
+	// package.json
+	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)}\n`,
+	)
+
+	// index.ts
+	writeFileSync(
+		resolve(sharedDir, 'index.ts'),
+		'// Shared utilities and exports\nexport * from \'./utils\'\n',
+	)
+
+	// utils/index.ts
+	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',
+	)
+
+	// types/index.ts
+	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('✅ Created shared package')
+}
+
+/**
+ * Add a new project to the workspace
+ */
+export async function addProject(
+	name: string,
+	root: string = process.cwd(),
+): Promise<void> {
+	const projectDir = resolve(root, name)
+
+	if (existsSync(projectDir)) {
+		console.error(`❌ Project ${name} already exists`)
+		process.exit(1)
+	}
+
+	console.log(`\n📦 Creating project: ${name}\n`)
+
+	mkdirSync(projectDir, { recursive: true })
+
+	// Determine if this is part of a workspace
+	const isWorkspace = existsSync(resolve(root, 'bgl.config.ts'))
+
+	// package.json
+	const packageJson: Record<string, unknown> = {
+		name,
+		type: 'module',
+		scripts: {
+			dev: 'vite',
+			build: 'vite build',
+			preview: 'vite preview',
+		},
+		dependencies: {} as Record<string, string>,
+		devDependencies: {
+			'@vitejs/plugin-vue': 'latest',
+			'vite': 'latest',
+			'vue': 'latest',
+		},
+	}
+
+	// Add shared dependency if in workspace
+	if (isWorkspace) {
+		(packageJson.dependencies as Record<string, string>).shared = 'workspace:*'
+	}
+
+	writeFileSync(
+		resolve(projectDir, 'package.json'),
+		`${JSON.stringify(packageJson, null, 2)}\n`,
+	)
+
+	// bgl.config.ts
+	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)
+
+	// vite.config.ts
+	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)
+
+	// Create basic src structure
+	const srcDir = resolve(projectDir, 'src')
+	mkdirSync(srcDir, { recursive: true })
+
+	// index.html
+	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)
+
+	// main.ts
+	const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`
+
+	writeFileSync(resolve(srcDir, 'main.ts'), mainTs)
+
+	// App.vue
+	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(`✅ Created project: ${name}`)
+
+	// Update workspace package.json if needed
+	if (isWorkspace) {
+		updateWorkspaceScripts(root, name)
+	}
+
+	console.log('\nNext steps:')
+	console.log(`  cd ${name}`)
+	console.log('  bun install')
+	console.log('  bun run dev')
+	console.log('')
+}
+
+/**
+ * Update workspace root package.json with new project scripts
+ */
+function updateWorkspaceScripts(root: string, projectName: string): void {
+	const packageJsonPath = resolve(root, 'package.json')
+	if (!existsSync(packageJsonPath)) return
+
+	try {
+		const packageJson = JSON.parse(
+			readFileSync(packageJsonPath, 'utf-8'),
+		)
+
+		if (!packageJson.scripts) {
+			packageJson.scripts = {}
+		}
+
+		// Add project-specific scripts
+		packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`
+		packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`
+
+		writeFileSync(
+			packageJsonPath,
+			`${JSON.stringify(packageJson, null, 2)}\n`,
+		)
+
+		console.log(`✅ Added scripts: dev:${projectName}, build:${projectName}`)
+	}
+	catch (error) {
+		console.warn('⚠️  Could not update workspace scripts')
+	}
+}
+
+/**
+ * List all projects in workspace
+ */
+export function listProjects(root: string = process.cwd()): string[] {
+	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 []
+	}
+}

package/templates/dev-runner.ts

@@ -0,0 +1,61 @@
+#!/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 !== '.git'
+			&& !item.name.startsWith('.'),
+	)
+	.map(item => item.name)
+
+console.log(`\n🚀 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(`  ✓ ${project.padEnd(15)} → ${match[1]}`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(`  ✗ ${project}: ${text.trim()}`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\n💡 Press Ctrl+C to stop all servers\n')
+
+process.on('SIGINT', () => {
+	console.log('\n\n👋 Stopping all servers...\n')
+	process.exit()
+})