@stack-dev/cli 0.1.0

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import base from '@stack-dev/eslint-config/base.mjs';
+
+export default [...base, { ignores: ['**/dist/**'] }];

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@stack-dev/cli",
+  "version": "0.1.0",
+  "bin": {
+    "stack": "./dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "enquirer": "^2.4.1",
+    "fast-glob": "^3.3.3",
+    "glob": "^11.0.3",
+    "json5": "^2.2.3",
+    "lodash": "^4.17.21",
+    "yaml": "^2.8.0",
+    "@stack-dev/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^24.0.15",
+    "eslint": "^9.32.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-organize-imports": "^4.2.0",
+    "tsup": "^7.3.0",
+    "@stack-dev/prettier-config": "0.1.0",
+    "@stack-dev/eslint-config": "0.1.0",
+    "@stack-dev/typescript-config": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "start": "node dist/index.js",
+    "check-types": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier . --write"
+  }
+}

package/prettier.config.mjs

@@ -0,0 +1,3 @@
+import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;

package/src/file-generator/file-generator-imp.ts

@@ -0,0 +1,20 @@
+import { FileGenerator } from './file-generator';
+
+export class FileGeneratorImp implements FileGenerator {
+  private readonly _filepath: string;
+
+  private readonly _contents: string;
+
+  public constructor(filepath: string, contents: string) {
+    this._filepath = filepath;
+    this._contents = contents;
+  }
+
+  public get filepath(): string {
+    return this._filepath;
+  }
+
+  public async generate(): Promise<string> {
+    return this._contents;
+  }
+}

package/src/file-generator/file-generator.ts

@@ -0,0 +1,5 @@
+export interface FileGenerator {
+  readonly filepath: string;
+
+  generate(): Promise<string>;
+}

package/src/file-generator/index.ts

@@ -0,0 +1,3 @@
+export * from './file-generator';
+
+export * from './package-json-generator';

package/src/file-generator/package-json-generator.ts

@@ -0,0 +1,23 @@
+import { FileGenerator } from './file-generator';
+import { PackageJSON } from '../package-json';
+
+export class PackageJsonGenerator implements FileGenerator {
+  private readonly _packageJson: PackageJSON;
+  private readonly _namespace: string;
+
+  public constructor(
+    packageJson: PackageJSON,
+    namespace: string = ''
+  ) {
+    this._packageJson = packageJson;
+    this._namespace = namespace;
+  }
+
+  public get filepath(): string {
+    return 'package.json';
+  }
+
+  public async generate(): Promise<string> {
+    return this._packageJson.format(this._namespace);
+  }
+}

package/src/index.ts

@@ -0,0 +1,185 @@
+import {
+  createConfigPackage,
+  createLibraryPackage,
+  createReactPackage,
+} from './packages';
+import {
+  comparePackages,
+  getAllPackages,
+  getCurrentPackage,
+  getPackageByName,
+} from './utils/package';
+import { packageTypes, pickPackageType } from './utils/package-type';
+import { pickStyleType, styleTypes } from './utils/style-type';
+
+import { Command } from 'commander';
+import { prompt } from 'enquirer';
+import { linkPackages } from './link-packages';
+import { createViteReactApp } from './packages/vite-react-app/create-vite-react-app';
+import { unlinkPackages } from './unlink-packages';
+import { getDirectoryPackageJson } from './utils/utils';
+import { getNamespace } from './utils/workspace';
+import { createWorkspace } from './workspace';
+
+const program = new 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':
+        // await createCliPackage(name)
+        break;
+      case 'fastify':
+        // await createFastifyApp(name)
+        break;
+      case 'next':
+        // await createNextPackage(name)
+        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(): Promise<string> {
+  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 prompt<{ packageName: string }>({
+    type: 'select',
+    name: 'packageName',
+    message: 'What package do you want to link to?',
+    choices: [...validOptions],
+  });
+
+  return response.packageName;
+}
+
+async function promptForPackageToUnlinkFrom(): Promise<string> {
+  const validOptions = await getLinkedPackageNames();
+
+  const response = await prompt<{ packageName: string }>({
+    type: 'select',
+    name: 'packageName',
+    message: 'What package do you want to unlink from?',
+    choices: [...validOptions],
+  });
+
+  return response.packageName;
+}
+
+async function getLinkedPackageNames(): Promise<Set<string>> {
+  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: string): Promise<boolean> {
+  const options = await getValidPackageNames();
+
+  return options.some((o) => o === packageName);
+}
+
+async function getValidPackageNames(): Promise<ReadonlyArray<string>> {
+  const options = await getAllPackages();
+  const currentPackage = await getCurrentPackage();
+
+  return options
+    .filter((o) => o.name !== currentPackage.name)
+    .map((o) => o.name);
+}

package/src/link-packages.ts

@@ -0,0 +1,65 @@
+import { Dependency, PackageJSON } from './package-json';
+import { getDirectoryPackageJson, getPackageJSONPath } from './utils/utils';
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TSConfig } from './tsconfig';
+import { Package } from './utils/package';
+import { getNamespace } from './utils/workspace';
+
+export async function linkPackages(
+  current: Package,
+  target: Package,
+  development: boolean,
+): Promise<void> {
+  await updatePackageJSON(current, target, development);
+  await updateTSConfig(current, target);
+}
+
+async function updatePackageJSON(
+  current: Package,
+  target: Package,
+  development: boolean,
+) {
+  const namespace = await getNamespace();
+
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = addDependency(packageJSON, target, development);
+
+  const packageJSONPath = getPackageJSONPath(current.directory);
+
+  await fs.writeFile(packageJSONPath, updated.format(namespace));
+}
+
+function addDependency(
+  packageJSON: PackageJSON,
+  target: Package,
+  development: boolean,
+): PackageJSON {
+  const dependency = new Dependency(target.name, 'workspace:*');
+
+  if (development) {
+    return packageJSON.addDevDependency(dependency);
+  } else {
+    return packageJSON.addDependency(dependency);
+  }
+}
+
+async function updateTSConfig(current: Package, target: Package) {
+  const tsconfigPath = path.join(current.directory, 'tsconfig.json');
+  const tsconfigContents = await fs.readFile(tsconfigPath, 'utf8');
+  const tsconfig = TSConfig.parse(tsconfigContents);
+
+  const targetDirectory = path.join(target.directory, 'src', 'index.ts');
+
+  const updatedPaths = {
+    ...tsconfig.compilerOptions.paths,
+    [target.name]: [path.relative(current.directory, targetDirectory)],
+  };
+  const updatedCompilerOptions =
+    tsconfig.compilerOptions.setPaths(updatedPaths);
+
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+
+  await fs.writeFile(tsconfigPath, updated.format());
+}

package/src/package-json/dependency.ts

@@ -0,0 +1,28 @@
+import { Equalable } from '@stack-dev/core';
+
+export class Dependency implements Equalable {
+  private readonly _name: string;
+
+  private readonly _version: string;
+
+  public constructor(name: string, version: string) {
+    this._name = name;
+    this._version = version;
+  }
+
+  public get name(): string {
+    return this._name;
+  }
+
+  public get version(): string {
+    return this._version;
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof Dependency) {
+      return this._name === other._name && this._version === other._version;
+    } else {
+      return false;
+    }
+  }
+}

package/src/package-json/index.ts

@@ -0,0 +1,3 @@
+export * from './package-json';
+
+export * from './dependency';

package/src/package-json/package-json.ts

@@ -0,0 +1,269 @@
+import { Equalable, haveSameItems, sortKeys } from '@stack-dev/core';
+
+import { Snapshot } from '@stack-dev/core';
+import JSON5 from 'json5';
+import { isEqual } from 'lodash';
+import { Dependency } from './dependency';
+
+export type ConstructorArgs = {
+  name: string;
+  dependencies?: ReadonlyArray<Dependency>;
+  devDependencies?: ReadonlyArray<Dependency>;
+  peerDependencies?: ReadonlyArray<Dependency>;
+  additionalData?: Snapshot;
+};
+
+export class PackageJSON implements Equalable {
+  private readonly _name: string;
+
+  private readonly _dependencies: ReadonlyArray<Dependency>;
+
+  private readonly _devDependencies: ReadonlyArray<Dependency>;
+
+  private readonly _peerDependencies: ReadonlyArray<Dependency>;
+
+  private readonly _additionalData: Snapshot;
+
+  public constructor(args: ConstructorArgs) {
+    this._name = args.name;
+    this._dependencies = args.dependencies ?? [];
+    this._devDependencies = args.devDependencies ?? [];
+    this._peerDependencies = args.peerDependencies ?? [];
+    this._additionalData = args.additionalData ?? {};
+  }
+
+  public get name(): string {
+    return this._name;
+  }
+
+  public get dependencies(): ReadonlyArray<Dependency> {
+    return this._dependencies;
+  }
+
+  public get devDependencies(): ReadonlyArray<Dependency> {
+    return this._devDependencies;
+  }
+
+  public get peerDependencies(): ReadonlyArray<Dependency> {
+    return this._peerDependencies;
+  }
+
+  public addDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: [...this.dependencies, dependency],
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData,
+    });
+  }
+
+  public addDevDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: [...this.devDependencies, dependency],
+      additionalData: this._additionalData,
+    });
+  }
+
+  public addPeerDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: [...this.peerDependencies, dependency],
+      additionalData: this._additionalData,
+    })
+  }
+
+  public removeDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies.filter((d) => d.name !== name),
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData,
+    });
+  }
+
+  public removeDevDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData,
+    });
+  }
+
+  public removePeerDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: this.peerDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData,
+    });
+  }
+
+  public static parse(s: string): PackageJSON {
+    const json = JSON5.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,
+    });
+  }
+
+  private static parseDependencies(json: Snapshot) {
+    if ('dependencies' in json && typeof json.dependencies === 'object') {
+      return Object.entries(json.dependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  private static parseDevDependencies(json: Snapshot) {
+    if ('devDependencies' in json && typeof json.devDependencies === 'object') {
+      return Object.entries(json.devDependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  private static parsePeerDependencies(json: Snapshot) {
+    if ('peerDependencies' in json && typeof json.peerDependencies === 'object') {
+      return Object.entries(json.peerDependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  public format(namespace: string): string {
+    const json = {
+      name: this._name,
+      dependencies: makeDependencyObject(this._dependencies, namespace),
+      devDependencies: makeDependencyObject(this._devDependencies, namespace),
+      peerDependencies: makeDependencyObject(this._peerDependencies, namespace),
+      ...this._additionalData,
+    };
+
+    const ordered = sortKeys(json, comparePackageJSONKeys);
+
+    return JSON.stringify(ordered, null, 2);
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof PackageJSON) {
+      const sameDependencies = haveSameItems(
+        this._dependencies,
+        other._dependencies,
+        (d1, d2) => d1.equals(d2),
+      );
+
+      const sameDevDependencies = haveSameItems(
+        this._devDependencies,
+        other._devDependencies,
+        (d1, d2) => d1.equals(d2),
+      );
+
+      const samePeerDependencies = haveSameItems(
+        this._peerDependencies,
+        other._peerDependencies,
+        (d1, d2) => d1.equals(d2),
+      )
+
+      return (
+        this._name === other._name &&
+        sameDependencies &&
+        sameDevDependencies &&
+        samePeerDependencies &&
+        isEqual(this._additionalData, other._additionalData)
+      );
+    } else {
+      return false;
+    }
+  }
+}
+
+function makeDependencyObject(
+  dependencies: ReadonlyArray<Dependency>,
+  namespace: string,
+): Record<string, string> | undefined {
+  if (dependencies.length === 0) {
+    return undefined;
+  }
+
+  const result: Record<string, string> = {};
+
+  dependencies
+    .toSorted((a, b) => comparePackageNames(a.name, b.name, namespace))
+    .forEach((d) => (result[d.name] = d.version));
+
+  return result;
+}
+
+function comparePackageNames(a: string, b: string, namespace: string): number {
+  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: string, b: string): number {
+  return getKeyIndex(a) - getKeyIndex(b);
+}
+
+function getKeyIndex(s: string): number {
+  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;
+  }
+}

package/src/packages/create-config-package.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { PackageJSON } from '../package-json';
+import { PackageJsonGenerator } from '../file-generator';
+import { PackageGenerator } from '../utils/package-generator';
+import { getNamespace, getWorkspaceRoot } from '../utils/workspace';
+
+export async function createConfigPackage(name: string): Promise<void> {
+  const rootDir = await getWorkspaceRoot();
+  const directory = path.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();
+}

package/src/packages/index.ts

@@ -0,0 +1,4 @@
+export * from './library-package';
+export * from './react-package';
+
+export * from './create-config-package';