@bagelink/workspace 1.7.4 → 1.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/workspace",
   "type": "module",
-  "version": "1.7.4",
+  "version": "1.9.0",
   "description": "Monorepo workspace tooling for Bagel projects with proxy and config management",
   "author": {
     "name": "Bagel Studio",
@@ -52,6 +52,14 @@
   "dependencies": {
     "prompts": "^2.4.2"
   },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@bagelink/lint-config": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "^24.0.0",
     "@types/prompts": "^2.4.9",
@@ -59,9 +67,6 @@
     "typescript": "^5.8.3",
     "unbuild": "^3.5.0"
   },
-  "peerDependencies": {
-    "vite": ">=5.0.0"
-  },
   "scripts": {
     "dev": "unbuild --stub",
     "build": "unbuild",

package/src/index.ts

@@ -34,6 +34,9 @@ export {
 	writeNetlifyConfig,
 }
 
+export { addProject, initWorkspace, listProjects } from './workspace'
+export { setupLint } from './lint'
+
 /**
  * Define workspace configuration
  * Simple helper to get config from a config map

package/src/lint.ts

@@ -0,0 +1,235 @@
+import { existsSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Set up linting in a project
+ */
+export async function setupLint(
+	root: string = process.cwd(),
+	isWorkspace: boolean = false,
+): Promise<void> {
+	console.log('\n🔍 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❌ Setup cancelled.\n')
+		process.exit(1)
+	}
+
+	const { configs, installDeps } = response
+
+	// Create config files
+	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)
+	}
+
+	// Update package.json
+	updatePackageJsonLint(root, configs)
+
+	if (installDeps) {
+		console.log('\n📦 Installing dependencies...')
+		console.log('Run: bun add -D @bagelink/lint-config eslint prettier typescript')
+	}
+
+	console.log('\n✅ 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('')
+}
+
+/**
+ * Create ESLint config
+ */
+function createEslintConfig(root: string, isWorkspace: boolean): void {
+	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('✅ Created eslint.config.js')
+}
+
+/**
+ * Create Prettier config
+ */
+function createPrettierConfig(root: string): void {
+	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)}\n`)
+	console.log('✅ Created .prettierrc')
+
+	// .prettierignore
+	const ignorePath = resolve(root, '.prettierignore')
+	const ignore = `dist
+node_modules
+.bun-cache
+*.min.js
+*.min.css
+`
+
+	writeFileSync(ignorePath, ignore)
+	console.log('✅ Created .prettierignore')
+}
+
+/**
+ * Create EditorConfig
+ */
+function createEditorConfig(root: string): void {
+	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('✅ Created .editorconfig')
+}
+
+/**
+ * Create Git Hooks
+ */
+function createGitHooks(root: string): void {
+	const packageJsonPath = resolve(root, 'package.json')
+
+	if (!existsSync(packageJsonPath)) {
+		console.warn('⚠️  No package.json found, skipping git hooks')
+		return
+	}
+
+	// .lintstagedrc
+	const lintStagedConfig = {
+		'*.{js,jsx,ts,tsx,vue}': ['eslint --fix'],
+		'*.{json,md,yml,yaml}': ['prettier --write'],
+	}
+
+	writeFileSync(
+		resolve(root, '.lintstagedrc'),
+		`${JSON.stringify(lintStagedConfig, null, 2)}\n`,
+	)
+
+	console.log('✅ Created .lintstagedrc')
+	console.log('ℹ️  Add simple-git-hooks and lint-staged to devDependencies')
+	console.log('   Then run: npx simple-git-hooks')
+}
+
+/**
+ * Update package.json with lint scripts
+ */
+function updatePackageJsonLint(root: string, configs: string[]): void {
+	const packageJsonPath = resolve(root, 'package.json')
+
+	if (!existsSync(packageJsonPath)) {
+		console.warn('⚠️  No package.json found')
+		return
+	}
+
+	try {
+		const packageJson = JSON.parse(
+			require('fs').readFileSync(packageJsonPath, 'utf-8'),
+		)
+
+		if (!packageJson.scripts) {
+			packageJson.scripts = {}
+		}
+
+		// Add lint scripts
+		if (configs.includes('eslint')) {
+			if (!packageJson.scripts.lint) {
+				packageJson.scripts.lint = 'eslint .'
+			}
+			if (!packageJson.scripts['lint:fix']) {
+				packageJson.scripts['lint:fix'] = 'eslint . --fix'
+			}
+		}
+
+		// Add format scripts
+		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)}\n`,
+		)
+
+		console.log('✅ Updated package.json with lint scripts')
+	}
+	catch (error) {
+		console.error('❌ Failed to update package.json:', error)
+	}
+}

package/src/workspace.ts

@@ -0,0 +1,432 @@
+import { existsSync, mkdirSync, readdirSync, 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
+
+	// Create workspace structure
+	createWorkspaceRoot(root, workspaceName, projectId)
+
+	// Create shared package
+	createSharedPackage(root)
+
+	if (createFirstProject && firstProjectName) {
+		await addProject(firstProjectName, root)
+	}
+
+	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 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)
+
+	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(
+			require('fs').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 []
+	}
+}