@bagelink/workspace 1.7.3 → 1.7.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/workspace",
   "type": "module",
-  "version": "1.7.3",
+  "version": "1.7.8",
   "description": "Monorepo workspace tooling for Bagel projects with proxy and config management",
   "author": {
     "name": "Bagel Studio",
@@ -52,16 +52,27 @@
   "dependencies": {
     "prompts": "^2.4.2"
   },
+  "peerDependencies": {
+    "@bagelink/lint-config": ">=1.0.0",
+    "@bagelink/sdk": ">=1.0.0",
+    "vite": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@bagelink/lint-config": {
+      "optional": true
+    },
+    "@bagelink/sdk": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@types/bun": "^1.1.16",
     "@types/node": "^24.0.0",
     "@types/prompts": "^2.4.9",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "unbuild": "^3.5.0"
   },
-  "peerDependencies": {
-    "vite": ">=5.0.0"
-  },
   "scripts": {
     "dev": "unbuild --stub",
     "build": "unbuild",

package/src/detect.ts

@@ -0,0 +1,90 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+
+/**
+ * Detect if current directory is a workspace root
+ */
+export function isWorkspace(root: string = process.cwd()): boolean {
+	// Check if package.json has workspaces field
+	const packageJsonPath = resolve(root, 'package.json')
+	if (existsSync(packageJsonPath)) {
+		try {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+			if (packageJson.workspaces !== undefined) {
+				return true
+			}
+		}
+		catch {
+			// Ignore parse errors
+		}
+	}
+
+	// Check if there are multiple project directories
+	// (directories with their own package.json, excluding shared, node_modules, etc.)
+	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')),
+		)
+
+		// If we have 2+ project directories, it's likely a workspace
+		return projectDirs.length >= 2
+	}
+	catch {
+		return false
+	}
+}
+
+/**
+ * Get workspace info
+ */
+export function getWorkspaceInfo(root: string = process.cwd()): {
+	isWorkspace: boolean
+	projects: string[]
+	hasShared: boolean
+} {
+	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,
+		}
+	}
+}

package/src/index.ts

@@ -34,6 +34,11 @@ export {
 	writeNetlifyConfig,
 }
 
+export { setupLint } from './lint'
+export { generateSDK, generateSDKForWorkspace } from './sdk'
+export { addProject, initWorkspace, listProjects } from './workspace'
+export { getWorkspaceInfo, isWorkspace } from './detect'
+
 /**
  * Define workspace configuration
  * Simple helper to get config from a config map

package/src/init.ts

@@ -1,7 +1,9 @@
+import type { WorkspaceConfig } from './types'
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import process from 'node:process'
 import prompts from 'prompts'
+import { writeNetlifyConfig } from './netlify'
 
 /**
  * Generate bgl.config.ts file interactively
@@ -75,12 +77,12 @@ export default defineWorkspace(configs)
 	console.log(`   Production host: ${productionHost}`)
 	console.log(`   Local dev host: http://localhost:8000\n`)
 
-	// Ask if they want to update package.json and vite.config
+	// Ask if they want to update package.json, vite.config, and netlify.toml
 	const setupResponse = await prompts([
 		{
 			type: 'confirm',
 			name: 'updatePackageJson',
-			message: 'Add dev scripts to package.json?',
+			message: 'Add/update dev scripts in package.json?',
 			initial: true,
 		},
 		{
@@ -89,6 +91,12 @@ export default defineWorkspace(configs)
 			message: 'Create/update vite.config.ts?',
 			initial: true,
 		},
+		{
+			type: 'confirm',
+			name: 'generateNetlify',
+			message: 'Generate netlify.toml for deployment?',
+			initial: true,
+		},
 	])
 
 	if (setupResponse.updatePackageJson) {
@@ -99,6 +107,14 @@ export default defineWorkspace(configs)
 		updateViteConfig(root)
 	}
 
+	if (setupResponse.generateNetlify) {
+		const prodConfig: WorkspaceConfig = {
+			host: productionHost,
+			proxy: '/api',
+		}
+		writeNetlifyConfig(prodConfig, resolve(root, 'netlify.toml'))
+	}
+
 	console.log('\n💡 You can edit these files to customize your configuration.\n')
 }
 
@@ -160,7 +176,7 @@ function updatePackageJsonScripts(root: string): void {
 			packageJson.scripts = {}
 		}
 
-		// Add scripts if they don't exist
+		// Add/overwrite dev scripts
 		const scriptsToAdd = {
 			'dev': 'vite',
 			'dev:local': 'vite --mode localhost',
@@ -168,20 +184,31 @@ function updatePackageJsonScripts(root: string): void {
 			'preview': 'vite preview',
 		}
 
-		let added = false
+		// Always overwrite dev and dev:local, preserve others if they exist
+		let modified = false
 		for (const [key, value] of Object.entries(scriptsToAdd)) {
-			if (!packageJson.scripts[key]) {
-				packageJson.scripts[key] = value
-				added = true
+			if (key === 'dev' || key === 'dev:local') {
+				// Always overwrite these
+				if (packageJson.scripts[key] !== value) {
+					packageJson.scripts[key] = value
+					modified = true
+				}
+			}
+			else {
+				// Only add if doesn't exist
+				if (!packageJson.scripts[key]) {
+					packageJson.scripts[key] = value
+					modified = true
+				}
 			}
 		}
 
-		if (added) {
+		if (modified) {
 			writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf-8')
 			console.log('✅ Updated package.json with dev scripts')
 		}
 		else {
-			console.log('ℹ️  Scripts already exist in package.json')
+			console.log('ℹ️  Scripts already up to date in package.json')
 		}
 	}
 	catch (error) {

package/src/lint.ts

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync, 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(
+			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/sdk.ts

@@ -0,0 +1,175 @@
+import type { WorkspaceConfig } from './types'
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Generate SDK from OpenAPI spec
+ */
+export async function generateSDK(
+	root: string = process.cwd(),
+): Promise<void> {
+	console.log('\n🔧 Generating SDK from OpenAPI...\n')
+
+	// Try to load config
+	let config: WorkspaceConfig | null = null
+	let openApiUrl: string | undefined
+
+	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 {
+		// Ignore config load errors
+	}
+
+	// Prompt for missing info
+	const response = await prompts([
+		{
+			type: openApiUrl !== undefined ? 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❌ SDK generation cancelled.\n')
+		process.exit(1)
+	}
+
+	const finalUrl = openApiUrl ?? response.openApiUrl
+	const { outputDir, splitFiles } = response
+
+	console.log(`\n📡 Fetching OpenAPI spec from: ${finalUrl}`)
+	console.log(`📁 Output directory: ${outputDir}\n`)
+
+	try {
+		// Dynamic import of @bagelink/sdk
+		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 })
+		}
+
+		// Write types
+		const typesPath = resolve(outputPath, 'types.d.ts')
+		writeFileSync(typesPath, types)
+		console.log('✅ Generated types.d.ts')
+
+		// Write API client
+		const apiPath = resolve(outputPath, 'api.ts')
+		writeFileSync(apiPath, code)
+		console.log('✅ Generated api.ts')
+
+		// Write index
+		const indexPath = resolve(outputPath, 'index.ts')
+		writeFileSync(
+			indexPath,
+			'export * from \'./api\'\nexport * from \'./types.d\'\n',
+		)
+		console.log('✅ Generated index.ts')
+
+		if (splitFiles) {
+			console.log('\n🔀 Splitting into organized files...')
+			console.log('ℹ️  File splitting requires @bagelink/sdk bin scripts')
+			console.log('    Keeping monolithic structure for now')
+			// Note: File splitting requires unpublished bin scripts
+			// Users can manually run: bunx bagelink generate
+		}
+
+		console.log('\n✅ SDK generated successfully!')
+		console.log(`\nImport it in your code:`)
+		console.log(`  import { api } from '${outputDir.replace('./src/', './')}'`)
+		console.log('')
+	}
+	catch (error: unknown) {
+		console.error('\n❌ 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)
+	}
+}
+
+/**
+ * Generate SDK for all projects in workspace
+ */
+export async function generateSDKForWorkspace(root: string = process.cwd()): Promise<void> {
+	console.log('\n🏢 Generating SDK for workspace projects...\n')
+
+	// Find all projects
+	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❌ No projects selected.\n')
+		return
+	}
+
+	for (const project of response.selectedProjects) {
+		console.log(`\n📦 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✅ All SDKs generated!')
+}