@stack-dev/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2097 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/utils/utils.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+
+// src/package-json/package-json.ts
+var import_core = require("@stack-dev/core");
+var import_json5 = __toESM(require("json5"));
+var import_lodash = require("lodash");
+
+// src/package-json/dependency.ts
+var Dependency = class _Dependency {
+  _name;
+  _version;
+  constructor(name, version) {
+    this._name = name;
+    this._version = version;
+  }
+  get name() {
+    return this._name;
+  }
+  get version() {
+    return this._version;
+  }
+  equals(other) {
+    if (other instanceof _Dependency) {
+      return this._name === other._name && this._version === other._version;
+    } else {
+      return false;
+    }
+  }
+};
+
+// src/package-json/package-json.ts
+var PackageJSON = class _PackageJSON {
+  _name;
+  _dependencies;
+  _devDependencies;
+  _peerDependencies;
+  _additionalData;
+  constructor(args) {
+    this._name = args.name;
+    this._dependencies = args.dependencies ?? [];
+    this._devDependencies = args.devDependencies ?? [];
+    this._peerDependencies = args.peerDependencies ?? [];
+    this._additionalData = args.additionalData ?? {};
+  }
+  get name() {
+    return this._name;
+  }
+  get dependencies() {
+    return this._dependencies;
+  }
+  get devDependencies() {
+    return this._devDependencies;
+  }
+  get peerDependencies() {
+    return this._peerDependencies;
+  }
+  addDependency(dependency) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: [...this.dependencies, dependency],
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData
+    });
+  }
+  addDevDependency(dependency) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: [...this.devDependencies, dependency],
+      additionalData: this._additionalData
+    });
+  }
+  addPeerDependency(dependency) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: [...this.peerDependencies, dependency],
+      additionalData: this._additionalData
+    });
+  }
+  removeDependency(name) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies.filter((d) => d.name !== name),
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData
+    });
+  }
+  removeDevDependency(name) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData
+    });
+  }
+  removePeerDependency(name) {
+    return new _PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: this.peerDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData
+    });
+  }
+  static parse(s) {
+    const json = import_json5.default.parse(s);
+    const name = json.name;
+    const dependencies = _PackageJSON.parseDependencies(json);
+    const devDependencies = _PackageJSON.parseDevDependencies(json);
+    const peerDependencies = _PackageJSON.parsePeerDependencies(json);
+    const additionalData = { ...json };
+    delete additionalData["name"];
+    delete additionalData["dependencies"];
+    delete additionalData["devDependencies"];
+    delete additionalData["peerDependencies"];
+    return new _PackageJSON({
+      name,
+      dependencies,
+      devDependencies,
+      peerDependencies,
+      additionalData
+    });
+  }
+  static parseDependencies(json) {
+    if ("dependencies" in json && typeof json.dependencies === "object") {
+      return Object.entries(json.dependencies).map(
+        ([name, version]) => new Dependency(name, version)
+      );
+    } else {
+      return [];
+    }
+  }
+  static parseDevDependencies(json) {
+    if ("devDependencies" in json && typeof json.devDependencies === "object") {
+      return Object.entries(json.devDependencies).map(
+        ([name, version]) => new Dependency(name, version)
+      );
+    } else {
+      return [];
+    }
+  }
+  static parsePeerDependencies(json) {
+    if ("peerDependencies" in json && typeof json.peerDependencies === "object") {
+      return Object.entries(json.peerDependencies).map(
+        ([name, version]) => new Dependency(name, version)
+      );
+    } else {
+      return [];
+    }
+  }
+  format(namespace) {
+    const json = {
+      name: this._name,
+      dependencies: makeDependencyObject(this._dependencies, namespace),
+      devDependencies: makeDependencyObject(this._devDependencies, namespace),
+      peerDependencies: makeDependencyObject(this._peerDependencies, namespace),
+      ...this._additionalData
+    };
+    const ordered = (0, import_core.sortKeys)(json, comparePackageJSONKeys);
+    return JSON.stringify(ordered, null, 2);
+  }
+  equals(other) {
+    if (other instanceof _PackageJSON) {
+      const sameDependencies = (0, import_core.haveSameItems)(
+        this._dependencies,
+        other._dependencies,
+        (d1, d2) => d1.equals(d2)
+      );
+      const sameDevDependencies = (0, import_core.haveSameItems)(
+        this._devDependencies,
+        other._devDependencies,
+        (d1, d2) => d1.equals(d2)
+      );
+      const samePeerDependencies = (0, import_core.haveSameItems)(
+        this._peerDependencies,
+        other._peerDependencies,
+        (d1, d2) => d1.equals(d2)
+      );
+      return this._name === other._name && sameDependencies && sameDevDependencies && samePeerDependencies && (0, import_lodash.isEqual)(this._additionalData, other._additionalData);
+    } else {
+      return false;
+    }
+  }
+};
+function makeDependencyObject(dependencies, namespace) {
+  if (dependencies.length === 0) {
+    return void 0;
+  }
+  const result = {};
+  dependencies.toSorted((a, b) => comparePackageNames(a.name, b.name, namespace)).forEach((d) => result[d.name] = d.version);
+  return result;
+}
+function comparePackageNames(a, b, namespace) {
+  if (a.startsWith(namespace) && b.startsWith(namespace)) {
+    return a.localeCompare(b);
+  } else if (a.startsWith(namespace)) {
+    return -1;
+  } else if (b.startsWith(namespace)) {
+    return 1;
+  } else {
+    return a.localeCompare(b);
+  }
+}
+function comparePackageJSONKeys(a, b) {
+  return getKeyIndex(a) - getKeyIndex(b);
+}
+function getKeyIndex(s) {
+  switch (s.toLowerCase()) {
+    case "name":
+      return 0;
+    case "version":
+      return 1;
+    case "private":
+      return 2;
+    case "bin":
+      return 3;
+    case "main":
+      return 4;
+    case "module":
+      return 5;
+    case "types":
+      return 6;
+    case "exports":
+      return 7;
+    case "scripts":
+      return 8;
+    case "dependencies":
+      return 9;
+    case "devDependencies":
+      return 10;
+    case "peerdependencies":
+      return 11;
+    default:
+      return Number.MAX_VALUE;
+  }
+}
+
+// src/utils/utils.ts
+async function getDirectoryPackageJson(directory) {
+  const packageJsonPath = getPackageJSONPath(directory);
+  const packageJsonText = await import_promises.default.readFile(packageJsonPath, {
+    encoding: "utf-8"
+  });
+  return PackageJSON.parse(packageJsonText);
+}
+function getPackageJSONPath(directory) {
+  return import_node_path.default.join(directory, "package.json");
+}
+async function fileExists(filepath) {
+  try {
+    await import_promises.default.access(filepath, import_promises.default.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/workspace.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_yaml = __toESM(require("yaml"));
+async function getDirectoryWorkspaceFile(directory) {
+  const raw = await getRawDirectoryWorkspaceFile(directory);
+  if ("packages" in raw && raw.packages instanceof Array) {
+    return {
+      packages: raw.packages.filter((p) => typeof p === "string")
+    };
+  } else {
+    return { packages: [] };
+  }
+}
+async function getRawDirectoryWorkspaceFile(directory) {
+  const case1 = import_path.default.join(directory, "pnpm-workspace.yaml");
+  const case2 = import_path.default.join(directory, "pnpm-workspace.yml");
+  if (await fileExists(case1)) {
+    return import_yaml.default.parse(await import_promises2.default.readFile(case1, { encoding: "utf-8" }));
+  } else if (await fileExists(case2)) {
+    return import_yaml.default.parse(await import_promises2.default.readFile(case2, { encoding: "utf-8" }));
+  } else {
+    throw new Error(`Directory "${directory}" is not a workspace.`);
+  }
+}
+async function isWorkspaceRoot(directory) {
+  return await fileExists(import_path.default.join(directory, "pnpm-workspace.yaml")) || await fileExists(import_path.default.join(directory, "pnpm-workspace.yml"));
+}
+async function getWorkspaceRoot(directory = process.cwd()) {
+  const parent = import_path.default.dirname(directory);
+  if (parent === directory) {
+    throw new Error("Not a workspace.");
+  }
+  if (await isWorkspaceRoot(directory)) {
+    return directory;
+  }
+  return getWorkspaceRoot(parent);
+}
+async function getNamespace(directory = process.cwd()) {
+  const root = await getWorkspaceRoot(directory);
+  const packageJson = await getDirectoryPackageJson(root);
+  const result = packageJson.name;
+  if (!result) {
+    throw new Error("Missing name.");
+  }
+  return `@${result}`;
+}
+
+// src/packages/library-package/create-library-package.ts
+var import_node_path3 = __toESM(require("path"));
+
+// src/file-generator/package-json-generator.ts
+var PackageJsonGenerator = class {
+  _packageJson;
+  _namespace;
+  constructor(packageJson, namespace = "") {
+    this._packageJson = packageJson;
+    this._namespace = namespace;
+  }
+  get filepath() {
+    return "package.json";
+  }
+  async generate() {
+    return this._packageJson.format(this._namespace);
+  }
+};
+
+// src/utils/package-generator.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var PackageGenerator = class {
+  _root;
+  _packageJson;
+  _fileGenerators;
+  constructor(root, packageJson, fileGenerators = []) {
+    this._root = root;
+    this._packageJson = packageJson;
+    this._fileGenerators = fileGenerators;
+  }
+  async generate() {
+    const all = [this._packageJson, ...this._fileGenerators];
+    await import_promises3.default.mkdir(this._root, { recursive: true });
+    await Promise.all(all.map((gen) => this.write(gen)));
+  }
+  async write(fileGenerator) {
+    const contents = await fileGenerator.generate();
+    const filepath = import_node_path2.default.join(this._root, fileGenerator.filepath);
+    const directory = import_node_path2.default.dirname(filepath);
+    await import_promises3.default.mkdir(directory, { recursive: true });
+    await import_promises3.default.writeFile(filepath, contents);
+  }
+};
+
+// src/file-generator/file-generator-imp.ts
+var FileGeneratorImp = class {
+  _filepath;
+  _contents;
+  constructor(filepath, contents) {
+    this._filepath = filepath;
+    this._contents = contents;
+  }
+  get filepath() {
+    return this._filepath;
+  }
+  async generate() {
+    return this._contents;
+  }
+};
+
+// src/packages/library-package/files/add-file-generator.ts
+var ADD_TS = `export function add(n1: number, n2: number): number {
+  return n1 + n2;
+}
+`;
+var ADD_FILE_GENERATOR = new FileGeneratorImp("src/add.ts", ADD_TS);
+
+// src/packages/library-package/files/add-spec-file-generator.ts
+var ADD_SPEC_TS = `import { describe, it, expect } from 'vitest';
+
+import { add } from '../add';
+
+describe('add', () => {
+  it('adds two numbers', () => {
+    expect(add(2, 3)).toBe(5);
+  });
+});
+`;
+var ADD_SPEC_FILE_GENERATOR = new FileGeneratorImp(
+  "src/spec/add.spec.ts",
+  ADD_SPEC_TS
+);
+
+// src/packages/library-package/files/eslint-config-file-generator.ts
+var ESLINT_CONFIG = `import base from '@stack-dev/eslint-config/base.mjs';
+
+export default [...base, { ignores: ['**/dist/**'] }];
+`;
+var ESLINT_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "eslint.config.mjs",
+  ESLINT_CONFIG
+);
+
+// src/packages/library-package/files/index-file-generator.ts
+var INDEX_TS = `export * from './add';
+`;
+var INDEX_FILE_GENERATOR = new FileGeneratorImp(
+  "src/index.ts",
+  INDEX_TS
+);
+
+// src/packages/library-package/files/prettier-config-file-generator.ts
+var PRETTIER_CONFIG = `import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;
+`;
+var PRETTIER_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "prettier.config.mjs",
+  PRETTIER_CONFIG
+);
+
+// src/packages/library-package/files/tsconfig-file-generator.ts
+var TSCONFIG = `{
+  "extends": "@stack-dev/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`;
+var TSCONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "tsconfig.json",
+  TSCONFIG
+);
+
+// src/packages/library-package/files/tsup-config-file-generator.ts
+var TSUP_CONFIG = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: 'esnext',
+  outExtension({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : '.js',
+    };
+  },
+});
+`;
+var TSUP_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "tsup.config.ts",
+  TSUP_CONFIG
+);
+
+// src/packages/library-package/files/vitest-config-file-generator.ts
+var VITEST_CONFIG = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+    },
+    environment: 'node',
+  },
+});
+`;
+var VITEST_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "vitest.config.ts",
+  VITEST_CONFIG
+);
+
+// src/packages/library-package/create-library-package.ts
+async function createLibraryPackage(name) {
+  const rootDir = await getWorkspaceRoot();
+  const directory = import_node_path3.default.join(rootDir, "packages", name);
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+  console.log(`\u2728 Creating config package: ${packageName}`);
+  const generator = new PackageGenerator(
+    directory,
+    makePackageGenerator(packageName, namespace),
+    [
+      INDEX_FILE_GENERATOR,
+      ADD_FILE_GENERATOR,
+      ADD_SPEC_FILE_GENERATOR,
+      TSUP_CONFIG_FILE_GENERATOR,
+      TSCONFIG_FILE_GENERATOR,
+      PRETTIER_CONFIG_FILE_GENERATOR,
+      ESLINT_CONFIG_FILE_GENERATOR,
+      VITEST_CONFIG_FILE_GENERATOR
+    ]
+  );
+  await generator.generate();
+  console.log(`\u2705 Config package created at: ${directory}`);
+}
+function makePackageGenerator(packageName, namespace) {
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    devDependencies: [
+      new Dependency(`${namespace}/eslint-config`, "workspace:*"),
+      new Dependency(`${namespace}/prettier-config`, "workspace:*"),
+      new Dependency(`${namespace}/typescript-config`, "workspace:*"),
+      new Dependency("eslint", "^9.32.0"),
+      new Dependency("prettier", "^3.6.2"),
+      new Dependency("prettier-plugin-organize-imports", "^4.2.0"),
+      new Dependency("tsup", "^7.3.0"),
+      new Dependency("vitest", "^3.2.4"),
+      new Dependency("@vitest/coverage-v8", "^3.2.4")
+    ],
+    additionalData: {
+      version: "0.1.0",
+      private: true,
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          development: "./src/index.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js",
+          types: "./dist/index.d.ts"
+        }
+      },
+      scripts: {
+        build: "tsup",
+        lint: "eslint",
+        format: "prettier . --write",
+        test: "vitest run",
+        "test:watch": "vitest"
+      },
+      sideEffects: false
+    }
+  });
+  return new PackageJsonGenerator(packageJsonModel, namespace);
+}
+
+// src/packages/react-package/create-tailwind-react-package.ts
+async function createTailwindReactPackage(name) {
+  throw new Error("Not implemented.");
+}
+var STYLED_BUTTON = `import React from 'react';
+
+interface ButtonProps {
+  label: string;
+  onClick?: () => void; 
+}
+
+export function TailwindButton(props: ButtonProps) {
+  const {label, onClick} = props;
+    
+  return (
+    <button 
+      onClick={onClick}
+      className="my-lib-bg-blue-600 my-lib-text-white my-lib-p-[10px] my-lib-border-none my-lib-rounded my-lib-cursor-pointer hover:my-lib-brightness-110"
+    >
+      {label}
+    </button>
+  );
+};`;
+var STYLED_BUTTON_FILE_GENERATOR = new FileGeneratorImp(
+  "styled-button.ts",
+  STYLED_BUTTON
+);
+
+// src/packages/react-package/create-unstyled-react-package.ts
+async function createUnstyledReactPackage(name) {
+  throw new Error("Not implemented.");
+}
+
+// src/packages/react-package/css-react-package/create-css-react-package.ts
+var import_path2 = __toESM(require("path"));
+
+// src/packages/react-package/css-react-package/files/button-css-module-file-generator.ts
+var BUTTON_CSS_MODULE = `.styledButton {
+  background: blue;
+  color: white;
+  padding: 10px;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+}
+`;
+var BUTTON_CSS_MODULE_FILE_GENERATOR = new FileGeneratorImp(
+  "src/button.module.css",
+  BUTTON_CSS_MODULE
+);
+
+// src/packages/react-package/css-react-package/files/button-file-generator.ts
+var BUTTON = `import React from 'react';
+import * as styles from './button.module.css';
+
+export function Button(props: HTMLAttributes<HTMLButtonElement>) {
+  return <button className={styles.styledButton} {...props} />;
+}
+`;
+var BUTTON_FILE_GENERATOR = new FileGeneratorImp(
+  "src/button.tsx",
+  BUTTON
+);
+
+// src/packages/react-package/css-react-package/files/button-spec-file-generator.ts
+var BUTTON_SPEC = `import { render, screen, fireEvent } from '@testing-library/react';
+import { Button } from './button';
+
+describe('Button', () => {
+  it('renders the label correctly', () => {
+    render(<Button>Click Me</Button>);
+    expect(screen.getByText('Click Me')).toBeDefined();
+  });
+
+  it('is a button element', () => {
+    render(<Button>Submit</Button>);
+    const buttonElement = screen.getByRole('button');
+    expect(buttonElement.tagName).toBe('BUTTON');
+  });
+
+  /* Note: Testing for specific CSS classes with CSS Modules is tricky 
+     because class names are mangled (e.g., _styledButton_123). 
+     Usually, we just test that the class attribute exists.
+  */
+  it('applies a class name', () => {
+    render(<Button>Styled</Button>);
+    const buttonElement = screen.getByRole('button');
+    expect(buttonElement.className).toBeTruthy();
+  });
+});
+`;
+var BUTTON_SPEC_FILE_GENERATOR = new FileGeneratorImp(
+  "src/button.spec.tsx",
+  BUTTON_SPEC
+);
+
+// src/packages/react-package/css-react-package/files/eslint-config-file-generator.ts
+var ESLINT_CONFIG2 = `import base from '@stack-dev/eslint-config/base.mjs';
+import react from '@stack-dev/eslint-config/react.mjs';
+
+export default [
+  ...base,
+  ...react,
+  { 
+    ignores: ['**/dist/**', '**/coverage/**'] 
+  }
+];
+`;
+var ESLINT_CONFIG_FILE_GENERATOR2 = new FileGeneratorImp(
+  "eslint.config.mjs",
+  ESLINT_CONFIG2
+);
+
+// src/packages/react-package/css-react-package/files/index-file-generator.ts
+var INDEX_TS2 = `export * from './button';
+`;
+var INDEX_FILE_GENERATOR2 = new FileGeneratorImp(
+  "src/index.ts",
+  INDEX_TS2
+);
+
+// src/packages/react-package/css-react-package/files/prettier-config-file-generator.ts
+var PRETTIER_CONFIG2 = `import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;
+`;
+var PRETTIER_CONFIG_FILE_GENERATOR2 = new FileGeneratorImp(
+  "prettier.config.mjs",
+  PRETTIER_CONFIG2
+);
+
+// src/packages/react-package/css-react-package/files/tsconfig-file-generator.ts
+var TSCONFIG2 = `{
+  "extends": "@stack-dev/typescript-config/tsconfig.react.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`;
+var TSCONFIG_FILE_GENERATOR2 = new FileGeneratorImp(
+  "tsconfig.json",
+  TSCONFIG2
+);
+
+// src/packages/react-package/css-react-package/files/tsup-config-file-generator.ts
+var TSUP_CONFIG2 = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  minify: true,
+  clean: true,
+  injectStyle: true,
+  external: ['react', 'react-dom'],
+  outExtension({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : '.js',
+    };
+  },
+});
+`;
+var TSUP_CONFIG_FILE_GENERATOR2 = new FileGeneratorImp(
+  "tsup.config.ts",
+  TSUP_CONFIG2
+);
+
+// src/packages/react-package/css-react-package/files/vitest-config-file-generator.ts
+var VITEST_CONFIG2 = `import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+    css: true,
+  },
+});
+`;
+var VITEST_CONFIG_FILE_GENERATOR2 = new FileGeneratorImp(
+  "vitest.config.ts",
+  VITEST_CONFIG2
+);
+
+// src/packages/react-package/css-react-package/create-css-react-package.ts
+async function createCssReactPackage(name) {
+  const rootDir = await getWorkspaceRoot();
+  const directory = import_path2.default.join(rootDir, "packages", name);
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+  console.log(`\u2728 Creating CSS Modules React library: ${packageName}`);
+  const generator = new PackageGenerator(
+    directory,
+    makePackageGenerator2(packageName, namespace),
+    [
+      INDEX_FILE_GENERATOR2,
+      BUTTON_FILE_GENERATOR,
+      BUTTON_CSS_MODULE_FILE_GENERATOR,
+      BUTTON_SPEC_FILE_GENERATOR,
+      TSUP_CONFIG_FILE_GENERATOR2,
+      TSCONFIG_FILE_GENERATOR2,
+      PRETTIER_CONFIG_FILE_GENERATOR2,
+      ESLINT_CONFIG_FILE_GENERATOR2,
+      VITEST_CONFIG_FILE_GENERATOR2
+    ]
+  );
+  await generator.generate();
+  console.log(`\u2705 Library created at: ${directory}`);
+}
+function makePackageGenerator2(packageName, namespace) {
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    peerDependencies: [
+      new Dependency("react", ">=18"),
+      new Dependency("react-dom", ">=18")
+    ],
+    devDependencies: [
+      new Dependency(`${namespace}/eslint-config`, "workspace:*"),
+      new Dependency(`${namespace}/prettier-config`, "workspace:*"),
+      new Dependency(`${namespace}/typescript-config`, "workspace:*"),
+      // Development React binaries
+      new Dependency("react", "^18.3.1"),
+      new Dependency("react-dom", "^18.3.1"),
+      new Dependency("@types/react", "^18.3.1"),
+      new Dependency("@types/react-dom", "^18.3.1"),
+      // Linting & Formatting
+      new Dependency("eslint", "^9.32.0"),
+      new Dependency("prettier", "^3.6.2"),
+      new Dependency("prettier-plugin-organize-imports", "^4.2.0"),
+      // Build
+      new Dependency("tsup", "^8.0.0"),
+      new Dependency("postcss", "^8.4.0"),
+      // Testing
+      new Dependency("vitest", "^3.2.4"),
+      new Dependency("@vitest/coverage-v8", "^3.2.4"),
+      new Dependency("@testing-library/react", "^16.0.0"),
+      new Dependency("@testing-library/jest-dom", "^6.0.0"),
+      new Dependency("jsdom", "^25.0.0")
+    ],
+    additionalData: {
+      version: "0.1.0",
+      private: true,
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          development: "./src/index.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js",
+          types: "./dist/index.d.ts"
+        },
+        "./index.css": "./dist/index.css"
+      },
+      scripts: {
+        build: "tsup",
+        lint: "eslint .",
+        format: "prettier . --write",
+        test: "vitest run",
+        "test:watch": "vitest"
+      },
+      sideEffects: ["**/*.css"]
+    }
+  });
+  return new PackageJsonGenerator(packageJsonModel, namespace);
+}
+
+// src/packages/react-package/styled-components-react-package/create-styled-components-react-package.ts
+var import_path3 = __toESM(require("path"));
+
+// src/packages/react-package/styled-components-react-package/files/button-file-generator.ts
+var BUTTON2 = `import React, { HTMLAttributes } from 'react';
+import styled from 'styled-components';
+
+// This is your "Styled" version of the button
+// No more imports, no more "empty objects"
+const StyledButton = styled.button\`
+  background-color: #007bff;
+  color: white;
+  padding: 10px 20px;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 16px;
+
+  &:hover {
+    background-color: #0056b3;
+  }
+\`;
+
+export function Button(props: HTMLAttributes<HTMLButtonElement>) {
+  return <StyledButton {...props} />;
+}
+`;
+var BUTTON_FILE_GENERATOR2 = new FileGeneratorImp(
+  "src/button.tsx",
+  BUTTON2
+);
+
+// src/packages/react-package/styled-components-react-package/files/button-spec-file-generator.ts
+var BUTTON_SPEC2 = `import { render, screen, fireEvent } from '@testing-library/react';
+import { Button } from './button';
+
+describe('Button', () => {
+  it('renders the label correctly', () => {
+    render(<Button>Click Me</Button>);
+    expect(screen.getByText('Click Me')).toBeDefined();
+  });
+
+  it('is a button element', () => {
+    render(<Button>Submit</Button>);
+    const buttonElement = screen.getByRole('button');
+    expect(buttonElement.tagName).toBe('BUTTON');
+  });
+
+  /* Note: Testing for specific CSS classes with CSS Modules is tricky 
+     because class names are mangled (e.g., _styledButton_123). 
+     Usually, we just test that the class attribute exists.
+  */
+  it('applies a class name', () => {
+    render(<Button>Styled</Button>);
+    const buttonElement = screen.getByRole('button');
+    expect(buttonElement.className).toBeTruthy();
+  });
+});
+`;
+var BUTTON_SPEC_FILE_GENERATOR2 = new FileGeneratorImp(
+  "src/button.spec.tsx",
+  BUTTON_SPEC2
+);
+
+// src/packages/react-package/styled-components-react-package/files/eslint-config-file-generator.ts
+var ESLINT_CONFIG3 = `import base from '@stack-dev/eslint-config/base.mjs';
+import react from '@stack-dev/eslint-config/react.mjs';
+
+export default [
+  ...base,
+  ...react,
+  { 
+    ignores: ['**/dist/**', '**/coverage/**'] 
+  }
+];
+`;
+var ESLINT_CONFIG_FILE_GENERATOR3 = new FileGeneratorImp(
+  "eslint.config.mjs",
+  ESLINT_CONFIG3
+);
+
+// src/packages/react-package/styled-components-react-package/files/index-file-generator.ts
+var INDEX_TS3 = `export * from './button';
+`;
+var INDEX_FILE_GENERATOR3 = new FileGeneratorImp(
+  "src/index.ts",
+  INDEX_TS3
+);
+
+// src/packages/react-package/styled-components-react-package/files/prettier-config-file-generator.ts
+var PRETTIER_CONFIG3 = `import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;
+`;
+var PRETTIER_CONFIG_FILE_GENERATOR3 = new FileGeneratorImp(
+  "prettier.config.mjs",
+  PRETTIER_CONFIG3
+);
+
+// src/packages/react-package/styled-components-react-package/files/tsconfig-file-generator.ts
+var TSCONFIG3 = `{
+  "extends": "@stack-dev/typescript-config/tsconfig.react.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`;
+var TSCONFIG_FILE_GENERATOR3 = new FileGeneratorImp(
+  "tsconfig.json",
+  TSCONFIG3
+);
+
+// src/packages/react-package/styled-components-react-package/files/tsup-config-file-generator.ts
+var TSUP_CONFIG3 = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  clean: true,
+  external: ['react', 'react-dom', 'styled-components'],
+  outExtension({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : '.js',
+    };
+  },
+});`;
+var TSUP_CONFIG_FILE_GENERATOR3 = new FileGeneratorImp(
+  "tsup.config.ts",
+  TSUP_CONFIG3
+);
+
+// src/packages/react-package/styled-components-react-package/files/vitest-config-file-generator.ts
+var VITEST_CONFIG3 = `import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+    css: true,
+  },
+});
+`;
+var VITEST_CONFIG_FILE_GENERATOR3 = new FileGeneratorImp(
+  "vitest.config.ts",
+  VITEST_CONFIG3
+);
+
+// src/packages/react-package/styled-components-react-package/create-styled-components-react-package.ts
+async function createStyledComponentsReactPackage(name) {
+  const rootDir = await getWorkspaceRoot();
+  const directory = import_path3.default.join(rootDir, "packages", name);
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+  console.log(
+    `\u2728 Creating Styled Components Modules React library: ${packageName}`
+  );
+  const generator = new PackageGenerator(
+    directory,
+    makePackageGenerator3(packageName, namespace),
+    [
+      INDEX_FILE_GENERATOR3,
+      BUTTON_FILE_GENERATOR2,
+      BUTTON_SPEC_FILE_GENERATOR2,
+      TSUP_CONFIG_FILE_GENERATOR3,
+      TSCONFIG_FILE_GENERATOR3,
+      PRETTIER_CONFIG_FILE_GENERATOR3,
+      ESLINT_CONFIG_FILE_GENERATOR3,
+      VITEST_CONFIG_FILE_GENERATOR3
+    ]
+  );
+  await generator.generate();
+  console.log(`\u2705 Library created at: ${directory}`);
+}
+function makePackageGenerator3(packageName, namespace) {
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    // Peer deps are crucial for Styled Components to prevent "Multiple instances" errors
+    peerDependencies: [
+      new Dependency("react", ">=18"),
+      new Dependency("react-dom", ">=18"),
+      new Dependency("styled-components", ">=6")
+    ],
+    devDependencies: [
+      new Dependency(`${namespace}/eslint-config`, "workspace:*"),
+      new Dependency(`${namespace}/prettier-config`, "workspace:*"),
+      new Dependency(`${namespace}/typescript-config`, "workspace:*"),
+      // Development React binaries
+      new Dependency("react", "^18.3.1"),
+      new Dependency("react-dom", "^18.3.1"),
+      new Dependency("@types/react", "^18.3.1"),
+      new Dependency("@types/react-dom", "^18.3.1"),
+      // Styled Components types and binary for build time
+      new Dependency("styled-components", "^6.1.13"),
+      new Dependency("@types/styled-components", "^5.1.34"),
+      // Linting & Formatting
+      new Dependency("eslint", "^9.32.0"),
+      new Dependency("prettier", "^3.6.2"),
+      new Dependency("prettier-plugin-organize-imports", "^4.2.0"),
+      // Build
+      new Dependency("tsup", "^8.0.0"),
+      // Testing
+      new Dependency("vitest", "^3.2.4"),
+      new Dependency("@vitest/coverage-v8", "^3.2.4"),
+      new Dependency("@testing-library/react", "^16.0.0"),
+      new Dependency("@testing-library/jest-dom", "^6.0.0"),
+      new Dependency("jsdom", "^25.0.0")
+    ],
+    additionalData: {
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      // Added this to ensure ESM consistency
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      exports: {
+        ".": {
+          development: "./src/index.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js",
+          types: "./dist/index.d.ts"
+        }
+        // Removed './index.css' as it's no longer produced by Styled Components
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        // Helpful for local lib dev
+        lint: "eslint .",
+        format: "prettier . --write",
+        test: "vitest run",
+        "test:watch": "vitest"
+      },
+      // Set to false or removed because Styled Components are pure JS/TS
+      sideEffects: false
+    }
+  });
+  return new PackageJsonGenerator(packageJsonModel, namespace);
+}
+
+// src/packages/react-package/create-react-package.ts
+async function createReactPackage(name, style) {
+  switch (style) {
+    case "tailwind":
+      await createTailwindReactPackage(name);
+      break;
+    case "css-modules":
+      await createCssReactPackage(name);
+      break;
+    case "styled-components":
+      await createStyledComponentsReactPackage(name);
+      break;
+    case "none":
+      await createUnstyledReactPackage(name);
+      break;
+  }
+}
+
+// src/packages/create-config-package.ts
+var import_node_path4 = __toESM(require("path"));
+async function createConfigPackage(name) {
+  const rootDir = await getWorkspaceRoot();
+  const directory = import_node_path4.default.join(rootDir, "configs", name);
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    additionalData: {
+      version: "0.1.0",
+      private: true
+    }
+  });
+  const generator = new PackageGenerator(
+    directory,
+    new PackageJsonGenerator(packageJsonModel, namespace),
+    []
+  );
+  await generator.generate();
+}
+
+// src/utils/package.ts
+var import_fast_glob = require("fast-glob");
+var import_node_path5 = __toESM(require("path"));
+async function getCurrentPackage(directory = process.cwd()) {
+  const packageRoot = await getPackageRoot(directory);
+  const packageJson = await getDirectoryPackageJson(packageRoot);
+  return getPackageByName(packageJson.name);
+}
+async function getPackageRoot(directory = process.cwd()) {
+  const parent = import_node_path5.default.dirname(directory);
+  if (parent === directory) {
+    throw new Error("Not a package.");
+  }
+  if (await isPackageRoot(directory)) {
+    return directory;
+  }
+  return getPackageRoot(parent);
+}
+async function getPackageByName(name) {
+  const all = await getAllPackages();
+  const match = all.find((p) => p.name === name);
+  if (match === void 0) {
+    throw new Error(`No package with name "${name}".`);
+  }
+  return match;
+}
+async function getAllPackages(directory = process.cwd()) {
+  const workspaceRoot = await getWorkspaceRoot(directory);
+  const workspaceFile = await getDirectoryWorkspaceFile(workspaceRoot);
+  const results = [];
+  for (const seg of workspaceFile.packages) {
+    const packageType = getPackageType(seg);
+    const packageJsonPaths = await (0, import_fast_glob.glob)(`${workspaceRoot}/${seg}/package.json`);
+    const packageDirectories = packageJsonPaths.map((p) => import_node_path5.default.dirname(p));
+    for (const directory2 of packageDirectories) {
+      const name = (await getDirectoryPackageJson(directory2)).name;
+      results.push({
+        name,
+        directory: directory2,
+        type: packageType
+      });
+    }
+  }
+  return results;
+}
+function getPackageType(segment) {
+  if (segment.startsWith("app")) {
+    return "App";
+  } else if (segment.startsWith("config")) {
+    return "Config";
+  } else if (segment.startsWith("package") || segment.startsWith("lib")) {
+    return "Library";
+  } else {
+    return "Unknown";
+  }
+}
+function comparePackages(a, b) {
+  const packageTypeDifference = comparePackageTypes(a.type, b.type);
+  if (packageTypeDifference !== 0) {
+    return packageTypeDifference;
+  } else {
+    return a.name.localeCompare(b.name);
+  }
+}
+function comparePackageTypes(a, b) {
+  return getPackageTypeIndex(a) - getPackageTypeIndex(b);
+}
+function getPackageTypeIndex(packageType) {
+  switch (packageType) {
+    case "Library":
+      return 0;
+    case "Config":
+      return 1;
+    case "App":
+      return 2;
+    case "Unknown":
+      return 3;
+  }
+}
+async function isPackageRoot(directory) {
+  return await fileExists(import_node_path5.default.join(directory, "package.json"));
+}
+
+// src/utils/package-type.ts
+var import_enquirer = require("enquirer");
+var packageTypes = [
+  "library",
+  "config",
+  "react",
+  "vite",
+  "fastify",
+  "next",
+  "cli"
+];
+async function pickPackageType(options) {
+  if (options?.type && isPackageType(options.type)) {
+    return options.type;
+  } else if (options?.type && !isPackageType(options.type)) {
+    throw new Error(
+      `--type setting "${options.type}" is invalid, must be one of ${packageTypes.join(", ")}.`
+    );
+  }
+  const response = await (0, import_enquirer.prompt)({
+    type: "select",
+    name: "type",
+    message: "What kind of package do you want?",
+    choices: [...packageTypes]
+  });
+  if (!isPackageType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${packageTypes.join(", ")}.`
+    );
+  }
+  return response.type;
+}
+function isPackageType(s) {
+  return packageTypes.some((p) => p === s);
+}
+
+// src/utils/style-type.ts
+var import_enquirer2 = require("enquirer");
+var styleTypes = [
+  "tailwind",
+  "css-modules",
+  "styled-components",
+  "none"
+];
+async function pickStyleType(options) {
+  if (options?.style && isStyleType(options?.style)) {
+    return options?.style;
+  } else if (options?.style && !isStyleType(options?.style)) {
+    throw new Error(
+      `--style setting "${options.style}" is invalid, must be one of ${styleTypes.join(", ")}.`
+    );
+  }
+  const response = await (0, import_enquirer2.prompt)({
+    type: "select",
+    name: "type",
+    message: "What kind of style do you want?",
+    choices: [...styleTypes]
+  });
+  if (!isStyleType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${styleTypes.join(", ")}.`
+    );
+  }
+  return response.type;
+}
+function isStyleType(s) {
+  return styleTypes.some((p) => p === s);
+}
+
+// src/index.ts
+var import_commander = require("commander");
+var import_enquirer3 = require("enquirer");
+
+// src/link-packages.ts
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path6 = __toESM(require("path"));
+
+// src/tsconfig/tsconfig.ts
+var JSON52 = __toESM(require("json5"));
+var import_core3 = require("@stack-dev/core");
+var import_lodash3 = require("lodash");
+
+// src/tsconfig/compiler-options.ts
+var import_core2 = require("@stack-dev/core");
+var import_lodash2 = require("lodash");
+var CompilerOptions = class _CompilerOptions {
+  _additionalData;
+  _paths;
+  constructor(args) {
+    this._paths = args?.paths ?? {};
+    this._additionalData = args?.additionalData ?? {};
+  }
+  get paths() {
+    return this._paths;
+  }
+  get additionalData() {
+    return this._additionalData;
+  }
+  setPaths(paths) {
+    return new _CompilerOptions({
+      paths,
+      additionalData: this._additionalData
+    });
+  }
+  format() {
+    const json = {
+      paths: this._paths,
+      ...this._additionalData
+    };
+    const ordered = (0, import_core2.sortKeys)(json, compareKeys);
+    return JSON.stringify(ordered, null, 2);
+  }
+  equals(other) {
+    if (other instanceof _CompilerOptions) {
+      return (0, import_lodash2.isEqual)(this._paths, other._paths) && (0, import_lodash2.isEqual)(this._additionalData, other._additionalData);
+    } else {
+      return false;
+    }
+  }
+};
+function compareKeys(a, b) {
+  return getKeyIndex2(a) - getKeyIndex2(b);
+}
+function getKeyIndex2(s) {
+  const order = [
+    "target",
+    "module",
+    "moduleResolution",
+    "esModuleInterop",
+    "lib",
+    "types",
+    "strict",
+    "allowJs"
+  ];
+  if (order.every((key) => key !== s)) {
+    return Number.MAX_VALUE;
+  } else {
+    return order.indexOf(s);
+  }
+}
+
+// src/tsconfig/reference.ts
+var Reference = class _Reference {
+  _path;
+  constructor(path14) {
+    this._path = path14;
+  }
+  get path() {
+    return this._path;
+  }
+  equals(other) {
+    if (other instanceof _Reference) {
+      return this._path === other._path;
+    } else {
+      return false;
+    }
+  }
+};
+
+// src/tsconfig/tsconfig.ts
+var TSConfig = class _TSConfig {
+  _compilerOptions;
+  _references;
+  _additionalData;
+  constructor(args) {
+    this._compilerOptions = args?.compilerOptions ?? new CompilerOptions();
+    this._references = args?.references ?? [];
+    this._additionalData = args?.additionalData ?? {};
+  }
+  get compilerOptions() {
+    return this._compilerOptions;
+  }
+  addReference(reference) {
+    return new _TSConfig({
+      compilerOptions: this._compilerOptions,
+      references: [...this._references, reference],
+      additionalData: this._additionalData
+    });
+  }
+  setCompilerOptions(compilerOptions) {
+    return new _TSConfig({
+      compilerOptions,
+      references: this._references,
+      additionalData: this._additionalData
+    });
+  }
+  static parse(s) {
+    const json = JSON52.parse(s);
+    const references = _TSConfig.parseReferences(json);
+    const compilerOptions = new CompilerOptions({
+      paths: json.compilerOptions?.paths,
+      ...json.compilerOptions
+    });
+    const additionalData = { ...json };
+    delete additionalData["compilerOptions"];
+    delete additionalData["references"];
+    return new _TSConfig({
+      compilerOptions,
+      references,
+      additionalData
+    });
+  }
+  static parseReferences(json) {
+    if (typeof json === "object" && json !== null && "references" in json && json.references instanceof Array) {
+      return json.references.map(
+        (r) => new Reference(r.path)
+      );
+    } else {
+      return [];
+    }
+  }
+  format() {
+    const compilerOptions = JSON52.parse(this.compilerOptions.format());
+    const json = {
+      compilerOptions,
+      references: this._references.map((r) => ({ path: r.path })),
+      ...this._additionalData
+    };
+    const ordered = (0, import_core3.sortKeys)(json, compareKeys2);
+    return JSON.stringify(ordered, null, 2);
+  }
+  equals(other) {
+    if (other instanceof _TSConfig) {
+      const sameReferences = (0, import_core3.haveSameItems)(
+        this._references,
+        other._references,
+        (r1, r2) => r1.equals(r2)
+      );
+      return this._compilerOptions.equals(other._compilerOptions) && sameReferences && (0, import_lodash3.isEqual)(this._additionalData, other._additionalData);
+    } else {
+      return false;
+    }
+  }
+};
+function compareKeys2(a, b) {
+  return getKeyIndex3(a) - getKeyIndex3(b);
+}
+function getKeyIndex3(s) {
+  const order = [
+    "extends",
+    "compilerOptions",
+    "include",
+    "exclude",
+    "references"
+  ];
+  if (order.every((key) => key !== s)) {
+    return Number.MAX_VALUE;
+  } else {
+    return order.indexOf(s);
+  }
+}
+
+// src/link-packages.ts
+async function linkPackages(current, target, development) {
+  await updatePackageJSON(current, target, development);
+  await updateTSConfig(current, target);
+}
+async function updatePackageJSON(current, target, development) {
+  const namespace = await getNamespace();
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = addDependency(packageJSON, target, development);
+  const packageJSONPath = getPackageJSONPath(current.directory);
+  await import_promises4.default.writeFile(packageJSONPath, updated.format(namespace));
+}
+function addDependency(packageJSON, target, development) {
+  const dependency = new Dependency(target.name, "workspace:*");
+  if (development) {
+    return packageJSON.addDevDependency(dependency);
+  } else {
+    return packageJSON.addDependency(dependency);
+  }
+}
+async function updateTSConfig(current, target) {
+  const tsconfigPath = import_node_path6.default.join(current.directory, "tsconfig.json");
+  const tsconfigContents = await import_promises4.default.readFile(tsconfigPath, "utf8");
+  const tsconfig = TSConfig.parse(tsconfigContents);
+  const targetDirectory = import_node_path6.default.join(target.directory, "src", "index.ts");
+  const updatedPaths = {
+    ...tsconfig.compilerOptions.paths,
+    [target.name]: [import_node_path6.default.relative(current.directory, targetDirectory)]
+  };
+  const updatedCompilerOptions = tsconfig.compilerOptions.setPaths(updatedPaths);
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+  await import_promises4.default.writeFile(tsconfigPath, updated.format());
+}
+
+// src/packages/vite-react-app/create-vite-react-app.ts
+var import_path4 = __toESM(require("path"));
+
+// src/packages/vite-react-app/files/index-html-file-generator.ts
+var INDEX_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + Stack-Dev</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+var INDEX_HTML_FILE_GENERATOR = new FileGeneratorImp(
+  "index.html",
+  INDEX_HTML
+);
+
+// src/packages/vite-react-app/files/main-file-generator.ts
+var MAIN = `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { App } from './App';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`;
+var MAIN_FILE_GENERATOR = new FileGeneratorImp("src/main.tsx", MAIN);
+
+// src/packages/vite-react-app/files/vite-config-file-generator.ts
+var VITE_CONFIG = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+  },
+});
+`;
+var VITE_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  "vite.config.ts",
+  VITE_CONFIG
+);
+
+// src/packages/vite-react-app/files/app-file-generator.ts
+var APP = `import React, { useState } from 'react';
+
+export function App() {
+  const [count, setCount] = useState(0);
+
+  return (
+    <div style={{ 
+      padding: '2rem', 
+      fontFamily: 'system-ui, sans-serif',
+      textAlign: 'center'
+    }}>
+      <h1>Stack-Dev App</h1>
+      <div className="card">
+        <button onClick={function() { setCount(count + 1) }}>
+          Count is {count}
+        </button>
+      </div>
+      <p>
+        Edit <code>src/App.tsx</code> and save to test HMR
+      </p>
+    </div>
+  );
+}
+`;
+var APP_FILE_GENERATOR = new FileGeneratorImp("src/App.tsx", APP);
+
+// src/packages/vite-react-app/files/eslint-config-file-generator.ts
+var ESLINT_CONFIG4 = `import base from '@stack-dev/eslint-config/base.mjs';
+
+export default [...base, { ignores: ['**/dist/**'] }];
+`;
+var ESLINT_CONFIG_FILE_GENERATOR4 = new FileGeneratorImp(
+  "eslint.config.mjs",
+  ESLINT_CONFIG4
+);
+
+// src/packages/vite-react-app/files/prettier-config-file-generator.ts
+var PRETTIER_CONFIG4 = `import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;
+`;
+var PRETTIER_CONFIG_FILE_GENERATOR4 = new FileGeneratorImp(
+  "prettier.config.mjs",
+  PRETTIER_CONFIG4
+);
+
+// src/packages/vite-react-app/files/tsconfig-file-generator.ts
+var TSCONFIG4 = `{
+  "extends": "@stack-dev/typescript-config/tsconfig.react.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`;
+var TSCONFIG_FILE_GENERATOR4 = new FileGeneratorImp(
+  "tsconfig.json",
+  TSCONFIG4
+);
+
+// src/packages/vite-react-app/files/vitest-config-file-generator.ts
+var VITEST_CONFIG4 = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+    },
+    environment: 'node',
+  },
+});
+`;
+var VITEST_CONFIG_FILE_GENERATOR4 = new FileGeneratorImp(
+  "vitest.config.ts",
+  VITEST_CONFIG4
+);
+
+// src/packages/vite-react-app/create-vite-react-app.ts
+async function createViteReactApp(name) {
+  const rootDir = await getWorkspaceRoot();
+  const directory = import_path4.default.join(rootDir, "apps", name);
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+  console.log(`\u{1F680} Creating Vite React App: ${packageName}`);
+  const generator = new PackageGenerator(
+    directory,
+    makeAppPackageGenerator(packageName, namespace),
+    [
+      VITE_CONFIG_FILE_GENERATOR,
+      INDEX_HTML_FILE_GENERATOR,
+      MAIN_FILE_GENERATOR,
+      APP_FILE_GENERATOR,
+      TSCONFIG_FILE_GENERATOR4,
+      PRETTIER_CONFIG_FILE_GENERATOR4,
+      ESLINT_CONFIG_FILE_GENERATOR4,
+      VITEST_CONFIG_FILE_GENERATOR4
+    ]
+  );
+  await generator.generate();
+}
+function makeAppPackageGenerator(packageName, namespace) {
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    dependencies: [
+      new Dependency("react", "^18.3.1"),
+      new Dependency("react-dom", "^18.3.1")
+    ],
+    devDependencies: [
+      new Dependency(`${namespace}/eslint-config`, "workspace:*"),
+      new Dependency(`${namespace}/prettier-config`, "workspace:*"),
+      new Dependency(`${namespace}/typescript-config`, "workspace:*"),
+      new Dependency("@types/react", "^18.3.1"),
+      new Dependency("@types/react-dom", "^18.3.1"),
+      new Dependency("@vitejs/plugin-react", "^4.3.1"),
+      new Dependency("vite", "^5.4.2"),
+      new Dependency("typescript", "^5.5.4"),
+      new Dependency("eslint", "^9.32.0"),
+      new Dependency("prettier", "^3.6.2")
+    ],
+    additionalData: {
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "vite",
+        build: "tsc && vite build",
+        preview: "vite preview",
+        start: "pnpm run preview",
+        lint: "eslint .",
+        format: "prettier . --write"
+      }
+    }
+  });
+  return new PackageJsonGenerator(packageJsonModel, namespace);
+}
+
+// src/unlink-packages.ts
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path7 = __toESM(require("path"));
+async function unlinkPackages(current, target) {
+  await updatePackageJSON2(current, target);
+  await updateTSConfig2(current, target);
+}
+async function updatePackageJSON2(current, target) {
+  const namespace = await getNamespace();
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = packageJSON.removeDependency(target.name).removeDevDependency(target.name);
+  const packageJSONPath = getPackageJSONPath(current.directory);
+  await import_promises5.default.writeFile(packageJSONPath, updated.format(namespace));
+}
+async function updateTSConfig2(current, target) {
+  const tsconfigPath = import_node_path7.default.join(current.directory, "tsconfig.json");
+  const tsconfigContents = await import_promises5.default.readFile(tsconfigPath, "utf8");
+  const tsconfig = TSConfig.parse(tsconfigContents);
+  const updatedPaths = Object.fromEntries(
+    Object.entries(tsconfig.compilerOptions.paths).filter(
+      ([key]) => key !== target.name
+    )
+  );
+  const updatedCompilerOptions = tsconfig.compilerOptions.setPaths(updatedPaths);
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+  await import_promises5.default.writeFile(tsconfigPath, updated.format());
+}
+
+// src/workspace/create-workspace.ts
+var import_promises6 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"));
+
+// src/workspace/root-package.ts
+async function makeRootPackage(directory, name) {
+  const packageJsonModel = new PackageJSON({
+    name,
+    devDependencies: [new Dependency("turbo", "^2.5.4")],
+    additionalData: {
+      description: "",
+      keywords: [],
+      author: "",
+      license: "ISC",
+      packageManager: "pnpm@10.13.1"
+    }
+  });
+  const PNPM_WORKSPACE = new FileGeneratorImp(
+    "pnpm-workspace.yaml",
+    ["packages:", "  - apps/*", "  - packages/*", "  - configs/*"].join("\n")
+  );
+  const GITIGNORE = new FileGeneratorImp(".gitignore", GITIGNORE_CONTENT);
+  const TURBO_JSON = new FileGeneratorImp(
+    "turbo.json",
+    JSON.stringify(
+      {
+        tasks: {
+          build: {
+            dependsOn: ["^build"],
+            outputs: ["dist/**"]
+          },
+          lint: {},
+          test: {}
+        }
+      },
+      null,
+      2
+    )
+  );
+  return new PackageGenerator(
+    directory,
+    new PackageJsonGenerator(packageJsonModel, ""),
+    [PNPM_WORKSPACE, GITIGNORE, TURBO_JSON]
+  );
+}
+var GITIGNORE_CONTENT = `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite logs files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+
+.turbo
+`;
+
+// src/workspace/typescript-config.ts
+var import_path5 = __toESM(require("path"));
+async function makeTypescriptConfig(directory, namespace) {
+  const packageJsonModel = new PackageJSON({
+    name: `${namespace}/typescript-config`,
+    devDependencies: [new Dependency("typescript", "^5.8.3")],
+    additionalData: {
+      version: "0.1.0",
+      private: true,
+      files: ["*.json"]
+    }
+  });
+  const fullPath = import_path5.default.join(directory, "configs/typescript-config");
+  return new PackageGenerator(
+    fullPath,
+    new PackageJsonGenerator(packageJsonModel, namespace),
+    [BASE, REACT, NODE]
+  );
+}
+var BASE = new FileGeneratorImp(
+  "tsconfig.base.json",
+  JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        resolveJsonModule: true,
+        isolatedModules: true,
+        strict: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        noEmit: true,
+        types: []
+      }
+    },
+    null,
+    2
+  )
+);
+var REACT = new FileGeneratorImp(
+  "tsconfig.react.json",
+  JSON.stringify(
+    {
+      extends: "./tsconfig.base.json",
+      compilerOptions: {
+        jsx: "react-jsx",
+        lib: ["DOM", "DOM.Iterable", "ES2022"],
+        types: []
+      }
+    },
+    null,
+    2
+  )
+);
+var NODE = new FileGeneratorImp(
+  "tsconfig.node.json",
+  JSON.stringify(
+    {
+      extends: "./tsconfig.base.json",
+      compilerOptions: {
+        lib: ["ES2022"],
+        types: ["node"]
+      }
+    },
+    null,
+    2
+  )
+);
+
+// src/workspace/create-workspace.ts
+async function createWorkspace(name, directory) {
+  await validateNotInWorkspace(directory);
+  console.log(`\u2728 Creating workspace: @${name}`);
+  const fullPath = import_path6.default.join(directory, name);
+  await import_promises6.default.mkdir(fullPath, { recursive: true });
+  const namespace = `@${name}`;
+  const PACKAGES = [
+    await makeRootPackage(fullPath, name),
+    await makeTypescriptConfig(fullPath, namespace)
+  ];
+  await Promise.all(PACKAGES.map((p) => p.generate()));
+  await import_promises6.default.mkdir(import_path6.default.join(fullPath, "apps"));
+  await import_promises6.default.mkdir(import_path6.default.join(fullPath, "configs"));
+  await import_promises6.default.mkdir(import_path6.default.join(fullPath, "packages"));
+  console.log(`\u2705 Workspace created at: ${fullPath}`);
+  console.log("");
+  console.log(`Run "cd ${fullPath}" followed by "pnpm install"`);
+}
+async function validateNotInWorkspace(directory) {
+  const namespace = await getNamespace(directory);
+  if (namespace !== void 0) {
+    throw new Error(`Currently in workspace "${namespace}".`);
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("stack").description("Opinionated TypeScript workspace manager").version("0.1.0");
+program.command("create <name>").description("Create a new workspace").option(
+  "-o, --output <dir>",
+  "Target directory to create the workspace in",
+  "."
+).action(async (name, options) => {
+  const output = options.output ?? process.cwd();
+  await createWorkspace(name, output);
+});
+program.command("g <name>").description("Generate a new package or app").option(
+  "-t, --type <type>",
+  `Type of package to generate (${packageTypes.join(", ")})`
+).option("--style <style>", `Styling system to use (${styleTypes.join(", ")})`).action(async (name, options) => {
+  const type = await pickPackageType(options);
+  switch (type) {
+    case "library":
+      await createLibraryPackage(name);
+      break;
+    case "config":
+      await createConfigPackage(name);
+      break;
+    case "react":
+      await createReactPackage(name, await pickStyleType(options));
+      break;
+    case "vite":
+      await createViteReactApp(name);
+      break;
+    case "cli":
+      break;
+    case "fastify":
+      break;
+    case "next":
+      break;
+  }
+  console.log("");
+  console.log("Run pnpm install to finish linking.");
+});
+program.command("link [name]").alias("l").option("-D, --dev", "Whether to link as a devDependency.", false).description("Link to the specified package").action(async (name, options) => {
+  name = name ?? await promptForPackageToLinkTo();
+  const development = options.dev ?? false;
+  if (!isValidPackageName(name)) {
+    throw new Error(`Package name "${name}" is not a valid option.`);
+  }
+  const current = await getCurrentPackage();
+  const target = await getPackageByName(name);
+  await linkPackages(current, target, development);
+  console.log("");
+  console.log("Run pnpm install to finish linking.");
+});
+program.command("unlink [name]").alias("u").description("Unlink the specified package").action(async (name) => {
+  name = name ?? await promptForPackageToUnlinkFrom();
+  if (!await isValidPackageName(name)) {
+    throw new Error(`Package name "${name}" is not a valid option.`);
+  }
+  const current = await getCurrentPackage();
+  const target = await getPackageByName(name);
+  await unlinkPackages(current, target);
+});
+async function promptForPackageToLinkTo() {
+  const options = await getAllPackages();
+  const currentPackage = await getCurrentPackage();
+  const linked = await getLinkedPackageNames();
+  const validOptions = options.filter((o) => o.name !== currentPackage.name).filter((o) => !linked.has(o.name)).toSorted(comparePackages);
+  const response = await (0, import_enquirer3.prompt)({
+    type: "select",
+    name: "packageName",
+    message: "What package do you want to link to?",
+    choices: [...validOptions]
+  });
+  return response.packageName;
+}
+async function promptForPackageToUnlinkFrom() {
+  const validOptions = await getLinkedPackageNames();
+  const response = await (0, import_enquirer3.prompt)({
+    type: "select",
+    name: "packageName",
+    message: "What package do you want to unlink from?",
+    choices: [...validOptions]
+  });
+  return response.packageName;
+}
+async function getLinkedPackageNames() {
+  const currentPackage = await getCurrentPackage();
+  const packageJSON = await getDirectoryPackageJson(currentPackage.directory);
+  const namespace = await getNamespace();
+  const names = [...packageJSON.dependencies, ...packageJSON.devDependencies].map((d) => d.name).filter((n) => n.startsWith(namespace));
+  return new Set(names);
+}
+program.parse();
+async function isValidPackageName(packageName) {
+  const options = await getValidPackageNames();
+  return options.some((o) => o === packageName);
+}
+async function getValidPackageNames() {
+  const options = await getAllPackages();
+  const currentPackage = await getCurrentPackage();
+  return options.filter((o) => o.name !== currentPackage.name).map((o) => o.name);
+}