@bagelink/workspace 1.7.4 → 1.9.0

package/dist/shared/workspace.CCUm_5GG.cjs

@@ -0,0 +1,746 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const process = require('node:process');
+const prompts = require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
+
+function generateNetlifyRedirect(config) {
+  const redirect = `[[redirects]]
+  from = "${config.proxy}/*"
+  to = "${config.host}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfig(config, additionalConfig) {
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig) {
+  const content = generateNetlifyConfig(config, additionalConfig);
+  const resolvedPath = node_path.resolve(outPath);
+  node_fs.writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+}
+function setBuildEnvVars(config) {
+  process__default.env.BGL_PROXY_PATH = config.proxy;
+  process__default.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process__default.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+async function generateWorkspaceConfig(root = process__default.cwd(), configFile = "bgl.config.ts") {
+  console.log("\n\u{1F527} No bgl.config.ts found. Let's create one!\n");
+  const response = await prompts__default([
+    {
+      type: "text",
+      name: "projectId",
+      message: "What is your Bagel project ID?",
+      initial: "my-project",
+      validate: (value) => value.length > 0 ? true : "Project ID is required"
+    },
+    {
+      type: "confirm",
+      name: "useCustomHost",
+      message: "Use custom production host?",
+      initial: false
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "customHost",
+      message: "Enter production host URL:",
+      initial: "https://api.example.com"
+    }
+  ]);
+  if (!response || !response.projectId) {
+    console.log("\n\u274C Config generation cancelled.\n");
+    process__default.exit(1);
+  }
+  const productionHost = response.useCustomHost === true ? response.customHost : `https://${response.projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`;
+  const configPath = node_path.resolve(root, configFile);
+  node_fs.writeFileSync(configPath, configContent, "utf-8");
+  console.log(`
+\u2705 Created ${configFile}`);
+  console.log(`   Production host: ${productionHost}`);
+  console.log(`   Local dev host: http://localhost:8000
+`);
+  const setupResponse = await prompts__default([
+    {
+      type: "confirm",
+      name: "updatePackageJson",
+      message: "Add/update dev scripts in package.json?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "updateViteConfig",
+      message: "Create/update vite.config.ts?",
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "generateNetlify",
+      message: "Generate netlify.toml for deployment?",
+      initial: true
+    }
+  ]);
+  if (setupResponse.updatePackageJson) {
+    updatePackageJsonScripts(root);
+  }
+  if (setupResponse.updateViteConfig) {
+    updateViteConfig(root);
+  }
+  if (setupResponse.generateNetlify) {
+    const prodConfig = {
+      host: productionHost,
+      proxy: "/api"
+    };
+    writeNetlifyConfig(prodConfig, node_path.resolve(root, "netlify.toml"));
+  }
+  console.log("\n\u{1F4A1} You can edit these files to customize your configuration.\n");
+}
+function generateWorkspaceConfigSync(projectId, root = process__default.cwd(), configFile = "bgl.config.ts", customHost) {
+  const productionHost = customHost ?? `https://${projectId}.bagel.to`;
+  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`;
+  const configPath = node_path.resolve(root, configFile);
+  node_fs.writeFileSync(configPath, configContent, "utf-8");
+  console.log(`\u2705 Created ${configPath}`);
+}
+function updatePackageJsonScripts(root) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.log("\u26A0\uFE0F  No package.json found, skipping script update");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    const scriptsToAdd = {
+      "dev": "vite",
+      "dev:local": "vite --mode localhost",
+      "build": "vite build",
+      "preview": "vite preview"
+    };
+    let modified = false;
+    for (const [key, value] of Object.entries(scriptsToAdd)) {
+      if (key === "dev" || key === "dev:local") {
+        if (packageJson.scripts[key] !== value) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      } else {
+        if (!packageJson.scripts[key]) {
+          packageJson.scripts[key] = value;
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      node_fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf-8");
+      console.log("\u2705 Updated package.json with dev scripts");
+    } else {
+      console.log("\u2139\uFE0F  Scripts already up to date in package.json");
+    }
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+function updateViteConfig(root) {
+  const viteConfigPath = node_path.resolve(root, "vite.config.ts");
+  const viteConfigExists = node_fs.existsSync(viteConfigPath);
+  if (viteConfigExists) {
+    const existingConfig = node_fs.readFileSync(viteConfigPath, "utf-8");
+    if (existingConfig.includes("@bagelink/workspace")) {
+      console.log("\u2139\uFE0F  vite.config.ts already configured");
+      return;
+    }
+    console.log("\u26A0\uFE0F  vite.config.ts exists. Please manually add the workspace configuration.");
+    console.log("    See: https://github.com/bageldb/bagelink/tree/master/packages/workspace#readme");
+    return;
+  }
+  const viteConfigContent = `import { defineConfig } from 'vite'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+// https://vitejs.dev/config/
+export default defineConfig(({ mode }) => {
+	const config = workspace(mode as 'localhost' | 'development' | 'production')
+
+	return {
+		server: {
+			proxy: createViteProxy(config),
+		},
+	}
+})
+`;
+  node_fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+  console.log("\u2705 Created vite.config.ts");
+}
+
+async function initWorkspace(root = process__default.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts__default([
+    {
+      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) => prev ? "text" : null,
+      name: "firstProjectName",
+      message: "First project name:",
+      initial: "web"
+    }
+  ]);
+  if (!response || !response.workspaceName) {
+    console.log("\n\u274C Workspace creation cancelled.\n");
+    process__default.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  createWorkspaceRoot(root, workspaceName, projectId);
+  createSharedPackage(root);
+  if (createFirstProject && firstProjectName) {
+    await addProject(firstProjectName, root);
+  }
+  console.log("\n\u2705 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("");
+}
+function createWorkspaceRoot(root, name, projectId) {
+  const workspaceDir = node_path.resolve(root, name);
+  if (node_fs.existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process__default.exit(1);
+  }
+  node_fs.mkdirSync(workspaceDir, { recursive: true });
+  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"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(workspaceDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  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',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(workspaceDir, "bgl.config.ts"), bglConfig);
+  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/*"]
+      }
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  node_fs.writeFileSync(node_path.resolve(workspaceDir, ".gitignore"), gitignore);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = node_path.resolve(root, "shared");
+  node_fs.mkdirSync(sharedDir, { recursive: true });
+  const packageJson = {
+    name: "shared",
+    version: "1.0.0",
+    type: "module",
+    exports: {
+      ".": "./index.ts",
+      "./utils": "./utils/index.ts",
+      "./types": "./types/index.ts"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "utils"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "types"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "types", "index.ts"),
+    "// Shared types\nexport interface User {\n  id: string\n  name: string\n}\n"
+  );
+  console.log("\u2705 Created shared package");
+}
+async function addProject(name, root = process__default.cwd()) {
+  const projectDir = node_path.resolve(root, name);
+  if (node_fs.existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process__default.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  node_fs.mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = node_fs.existsSync(node_path.resolve(root, "bgl.config.ts"));
+  const packageJson = {
+    name,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {},
+    devDependencies: {
+      "@vitejs/plugin-vue": "latest",
+      vite: "latest",
+      vue: "latest"
+    }
+  };
+  if (isWorkspace) {
+    packageJson.dependencies.shared = "workspace:*";
+  }
+  node_fs.writeFileSync(
+    node_path.resolve(projectDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  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',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  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),
+		},
+	}
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "vite.config.ts"), viteConfig);
+  const srcDir = node_path.resolve(projectDir, "src");
+  node_fs.mkdirSync(srcDir, { recursive: true });
+  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>
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "index.html"), indexHtml);
+  const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`;
+  node_fs.writeFileSync(node_path.resolve(srcDir, "main.ts"), mainTs);
+  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>
+`;
+  node_fs.writeFileSync(node_path.resolve(srcDir, "App.vue"), appVue);
+  console.log(`\u2705 Created project: ${name}`);
+  if (isWorkspace) {
+    updateWorkspaceScripts(root, name);
+  }
+  console.log("\nNext steps:");
+  console.log(`  cd ${name}`);
+  console.log("  bun install");
+  console.log("  bun run dev");
+  console.log("");
+}
+function updateWorkspaceScripts(root, projectName) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      require("fs").readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`;
+    packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`;
+    node_fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log(`\u2705 Added scripts: dev:${projectName}, build:${projectName}`);
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Could not update workspace scripts");
+  }
+}
+function listProjects(root = process__default.cwd()) {
+  try {
+    const items = node_fs.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 [];
+  }
+}
+
+async function setupLint(root = process__default.cwd(), isWorkspace = false) {
+  console.log("\n\u{1F50D} Setting up linting...\n");
+  const response = await prompts__default([
+    {
+      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\u274C Setup cancelled.\n");
+    process__default.exit(1);
+  }
+  const { configs, installDeps } = response;
+  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);
+  }
+  updatePackageJsonLint(root, configs);
+  if (installDeps) {
+    console.log("\n\u{1F4E6} Installing dependencies...");
+    console.log("Run: bun add -D @bagelink/lint-config eslint prettier typescript");
+  }
+  console.log("\n\u2705 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("");
+}
+function createEslintConfig(root, isWorkspace) {
+  const configPath = node_path.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
+`;
+  node_fs.writeFileSync(configPath, config);
+  console.log("\u2705 Created eslint.config.js");
+}
+function createPrettierConfig(root) {
+  const configPath = node_path.resolve(root, ".prettierrc");
+  const config = {
+    semi: false,
+    singleQuote: true,
+    tabWidth: 2,
+    useTabs: true,
+    trailingComma: "all",
+    printWidth: 100,
+    arrowParens: "avoid"
+  };
+  node_fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  console.log("\u2705 Created .prettierrc");
+  const ignorePath = node_path.resolve(root, ".prettierignore");
+  const ignore = `dist
+node_modules
+.bun-cache
+*.min.js
+*.min.css
+`;
+  node_fs.writeFileSync(ignorePath, ignore);
+  console.log("\u2705 Created .prettierignore");
+}
+function createEditorConfig(root) {
+  const configPath = node_path.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
+`;
+  node_fs.writeFileSync(configPath, config);
+  console.log("\u2705 Created .editorconfig");
+}
+function createGitHooks(root) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found, skipping git hooks");
+    return;
+  }
+  const lintStagedConfig = {
+    "*.{js,jsx,ts,tsx,vue}": ["eslint --fix"],
+    "*.{json,md,yml,yaml}": ["prettier --write"]
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(root, ".lintstagedrc"),
+    `${JSON.stringify(lintStagedConfig, null, 2)}
+`
+  );
+  console.log("\u2705 Created .lintstagedrc");
+  console.log("\u2139\uFE0F  Add simple-git-hooks and lint-staged to devDependencies");
+  console.log("   Then run: npx simple-git-hooks");
+}
+function updatePackageJsonLint(root, configs) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) {
+    console.warn("\u26A0\uFE0F  No package.json found");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(
+      require("fs").readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (configs.includes("eslint")) {
+      if (!packageJson.scripts.lint) {
+        packageJson.scripts.lint = "eslint .";
+      }
+      if (!packageJson.scripts["lint:fix"]) {
+        packageJson.scripts["lint:fix"] = "eslint . --fix";
+      }
+    }
+    if (configs.includes("prettier")) {
+      if (!packageJson.scripts.format) {
+        packageJson.scripts.format = "prettier --write .";
+      }
+      if (!packageJson.scripts["format:check"]) {
+        packageJson.scripts["format:check"] = "prettier --check .";
+      }
+    }
+    node_fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log("\u2705 Updated package.json with lint scripts");
+  } catch (error) {
+    console.error("\u274C Failed to update package.json:", error);
+  }
+}
+
+exports.addProject = addProject;
+exports.generateNetlifyConfig = generateNetlifyConfig;
+exports.generateNetlifyRedirect = generateNetlifyRedirect;
+exports.generateWorkspaceConfig = generateWorkspaceConfig;
+exports.generateWorkspaceConfigSync = generateWorkspaceConfigSync;
+exports.initWorkspace = initWorkspace;
+exports.listProjects = listProjects;
+exports.setBuildEnvVars = setBuildEnvVars;
+exports.setupLint = setupLint;
+exports.writeNetlifyConfig = writeNetlifyConfig;