@elaraai/create-east 1.0.4 → 1.0.5

package/bin/create-east.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Licensed under AGPL-3.0-or-later. See LICENSE for details.
+ *
+ * Static bin shim — exists in fresh checkout so pnpm install can create
+ * the bin symlink BEFORE the package is built. Dynamic-imports the
+ * built CLI entrypoint; argv flows through via process.argv.
+ */
+await import('../dist/index.js');

package/dist/index.js

@@ -39,15 +39,38 @@ var DOTFILE_RENAMES = {
   gitignore: ".gitignore",
   npmrc: ".npmrc"
 };
+var MANIFEST_FILE = "template.json";
 function substituteTokens(content, names) {
   return content.replaceAll("__PROJECT_NAME__", names.projectName).replaceAll("__DISPLAY_NAME__", names.displayName).replaceAll("__WORKSPACE_NAME__", names.workspaceName);
 }
-function transformPackageJson(raw, names, version) {
+function transformPackageJson(raw, names, version, manifest, enabled) {
   const pkg = JSON.parse(raw);
   pkg.name = `@elaraai/${names.projectName}`;
   pkg.description = names.displayName;
   pkg.version = "0.0.1";
   delete pkg.private;
+  if (manifest) {
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    const scripts = pkg.scripts;
+    for (const [feature, spec] of Object.entries(manifest.features)) {
+      if (enabled(feature))
+        continue;
+      for (const d of spec.dependencies ?? [])
+        delete deps?.[d];
+      for (const d of spec.devDependencies ?? [])
+        delete devDeps?.[d];
+      for (const s of spec.scripts ?? [])
+        delete scripts?.[s];
+    }
+    for (const [name, variants] of Object.entries(manifest.scriptVariants ?? {})) {
+      const match = variants.find((v) => v.when.every(enabled));
+      if (match)
+        scripts[name] = match.value;
+      else
+        delete scripts?.[name];
+    }
+  }
   const pin = `^${version}`;
   for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
     const deps = pkg[field];
@@ -77,6 +100,12 @@ function extOf(path) {
   const dot = base.lastIndexOf(".");
   return dot <= 0 ? "" : base.slice(dot);
 }
+function loadManifest(templateDir) {
+  const path = join(templateDir, MANIFEST_FILE);
+  if (!existsSync(path))
+    return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
 function scaffold(options) {
   const { kind, name, templateDir, version } = options;
   const cwd = options.cwd ?? process.cwd();
@@ -84,6 +113,23 @@ function scaffold(options) {
   if (!existsSync(templateDir)) {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
+  const manifest = loadManifest(templateDir);
+  const enabled = (feature) => options.features?.[feature] ?? manifest?.features[feature]?.default ?? true;
+  const skip = /* @__PURE__ */ new Set();
+  const renames = {};
+  if (manifest) {
+    for (const [feature, spec] of Object.entries(manifest.features)) {
+      if (enabled(feature)) {
+        for (const f of spec.disable ?? [])
+          skip.add(f);
+        for (const [src, dest] of Object.entries(spec.rename ?? {}))
+          renames[src] = dest;
+      } else {
+        for (const f of spec.files ?? [])
+          skip.add(f);
+      }
+    }
+  }
   const names = deriveNames(name, cwd);
   const inPlace = name === ".";
   const projectDir = inPlace ? cwd : join(cwd, names.projectName);
@@ -92,17 +138,21 @@ function scaffold(options) {
   }
   mkdirSync(projectDir, { recursive: true });
   for (const srcPath of walk(templateDir)) {
-    const rel = relative(templateDir, srcPath);
-    const segments = rel.split(/[/\\]/);
+    const rel = relative(templateDir, srcPath).replaceAll("\\", "/");
+    if (rel === MANIFEST_FILE)
+      continue;
+    if (skip.has(rel))
+      continue;
+    const destRel = renames[rel] ?? rel;
+    const segments = destRel.split("/");
     const last = segments[segments.length - 1];
     segments[segments.length - 1] = DOTFILE_RENAMES[last] ?? last;
-    const destRel = segments.join("/");
-    const destPath = join(projectDir, destRel);
+    const destPath = join(projectDir, segments.join("/"));
     mkdirSync(join(destPath, ".."), { recursive: true });
     const baseName = segments[segments.length - 1];
     if (baseName === "package.json") {
-      const manifest = transformPackageJson(readFileSync(srcPath, "utf8"), names, version);
-      writeFileSync(destPath, substituteTokens(manifest, names));
+      const transformed = transformPackageJson(readFileSync(srcPath, "utf8"), names, version, manifest, enabled);
+      writeFileSync(destPath, substituteTokens(transformed, names));
     } else if (TEXT_REPLACE_EXT.has(extOf(srcPath)) || baseName.startsWith(".")) {
       writeFileSync(destPath, substituteTokens(readFileSync(srcPath, "utf8"), names));
     } else {
@@ -111,7 +161,7 @@ function scaffold(options) {
   }
   log(`Created ${names.projectName} (${kind}) at ${projectDir}`);
   if (options.install) {
-    runInstall(kind, projectDir, log);
+    runInstall(kind, projectDir, enabled, log);
   }
   return { ...names, projectDir, inPlace };
 }
@@ -119,14 +169,14 @@ function hasCommand(cmd) {
   const probe = process.platform === "win32" ? "where" : "which";
   return spawnSync(probe, [cmd], { stdio: "ignore" }).status === 0;
 }
-function runInstall(kind, projectDir, log) {
+function runInstall(kind, projectDir, enabled, log) {
   log("Installing Node dependencies (npm install)...");
   const npm = spawnSync("npm", ["install"], { cwd: projectDir, stdio: "inherit", shell: process.platform === "win32" });
   if (npm.status !== 0) {
     log("npm install failed \u2014 fix the issue and re-run `npm install`.");
     return;
   }
-  if (kind === "e3") {
+  if (kind === "e3" && enabled("runner:east-py")) {
     if (hasCommand("uv")) {
       log("Installing Python dependencies (uv sync)...");
       const uv = spawnSync("uv", ["sync"], { cwd: projectDir, stdio: "inherit", shell: process.platform === "win32" });
@@ -139,15 +189,15 @@ function runInstall(kind, projectDir, log) {
 }
 
 // ../scaffold-core/dist/cli.js
-import { readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-function runCreateCli(kind, moduleUrl) {
+async function runCreateCli(kind, moduleUrl) {
   const pkgRoot = join2(dirname(fileURLToPath(moduleUrl)), "..");
   const args = process.argv.slice(2);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log(`Usage: npm create @elaraai/${kind} <project-name> [-- --install|--no-install]`);
-    console.log(`       create-${kind} <project-name|.> [--install|--no-install]`);
+    printHelp(kind);
     return;
   }
   const version = JSON.parse(readFileSync2(join2(pkgRoot, "package.json"), "utf8")).version;
@@ -155,22 +205,111 @@ function runCreateCli(kind, moduleUrl) {
   const name = args.find((a) => !a.startsWith("-")) ?? ".";
   const install = args.includes("--install") ? true : args.includes("--no-install") ? false : Boolean(process.stdout.isTTY);
   try {
-    const result = scaffold({ kind, name, templateDir, version, install });
-    printNextSteps(kind, result.projectName, result.inPlace, install);
+    const features = await resolveFeatures(templateDir, args);
+    const result = scaffold({ kind, name, templateDir, version, install, features });
+    printNextSteps(kind, result.projectName, result.inPlace, install, features);
   } catch (err) {
     console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
 }
-function printNextSteps(kind, projectName, inPlace, installed) {
+async function resolveFeatures(templateDir, args) {
+  const manifestPath = join2(templateDir, "template.json");
+  if (!existsSync2(manifestPath))
+    return {};
+  const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  const features = {};
+  for (const [key, spec] of Object.entries(manifest.features))
+    features[key] = spec.default ?? true;
+  const runnerKeys = Object.keys(manifest.features).filter((k) => k.startsWith("runner:"));
+  const runnerName = (key) => key.slice("runner:".length);
+  const runnersFlag = args.find((a) => a.startsWith("--runners="));
+  const selectionFlags = ["--tests", "--no-tests", "--ui", "--no-ui", "--eslint", "--no-eslint"].some((f) => args.includes(f)) || Boolean(runnersFlag);
+  if (args.includes("--tests"))
+    features["tests"] = true;
+  if (args.includes("--no-tests"))
+    features["tests"] = false;
+  if (args.includes("--ui"))
+    features["ui"] = true;
+  if (args.includes("--no-ui"))
+    features["ui"] = false;
+  if (args.includes("--eslint"))
+    features["eslint"] = true;
+  if (args.includes("--no-eslint"))
+    features["eslint"] = false;
+  if (args.includes("--editor-diagnostics"))
+    features["editor-diagnostics"] = true;
+  if (args.includes("--no-editor-diagnostics"))
+    features["editor-diagnostics"] = false;
+  if (runnersFlag) {
+    const chosen = new Set(runnersFlag.slice("--runners=".length).split(",").map((s) => s.trim()).filter(Boolean));
+    for (const key of runnerKeys)
+      features[key] = chosen.has(runnerName(key));
+  }
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !selectionFlags;
+  if (!interactive)
+    return features;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if ("tests" in manifest.features) {
+      features["tests"] = await askYesNo(rl, "Include tests?", features["tests"]);
+    }
+    if ("ui" in manifest.features) {
+      features["ui"] = await askYesNo(rl, "Include UI components (east-ui + e3-ui)?", features["ui"]);
+    }
+    if (runnerKeys.length > 0) {
+      const defaults = runnerKeys.filter((k) => features[k]).map(runnerName);
+      const answer = (await rl.question(`Runners to include (comma-separated) [${defaults.join(",")}]: `)).trim();
+      const picks = new Set(answer ? answer.split(",").map((s) => s.trim()).filter(Boolean) : defaults);
+      for (const key of runnerKeys)
+        features[key] = picks.has(runnerName(key));
+    }
+    if ("eslint" in manifest.features) {
+      features["eslint"] = await askYesNo(rl, "Include ESLint with the East lint rules?", features["eslint"]);
+    }
+    if ("editor-diagnostics" in manifest.features) {
+      features["editor-diagnostics"] = await askYesNo(rl, "Include East editor diagnostics (TypeScript language service plugin)?", features["editor-diagnostics"]);
+    }
+  } finally {
+    rl.close();
+  }
+  return features;
+}
+async function askYesNo(rl, question, def) {
+  const answer = (await rl.question(`${question} [${def ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+  if (answer === "")
+    return def;
+  return answer.startsWith("y");
+}
+function printHelp(kind) {
+  console.log(`Usage: npm create @elaraai/${kind} <project-name> [-- <options>]`);
+  console.log(`       create-${kind} <project-name|.> [options]`);
+  console.log("");
+  console.log("Options:");
+  console.log("  --install | --no-install     install dependencies after scaffolding (default: TTY)");
+  console.log("  --eslint | --no-eslint       include ESLint with the East lint rules (default: yes)");
+  console.log("  --editor-diagnostics | --no-editor-diagnostics   include the East tsserver plugin for editor squiggles (default: yes)");
+  if (kind === "e3") {
+    console.log("  --tests | --no-tests         include test files (default: yes)");
+    console.log("  --ui | --no-ui               include east-ui + e3-ui UI components (default: no)");
+    console.log("  --runners=east-node,east-c,east-py   East runtimes to include (default: all)");
+  }
+  console.log("");
+  console.log("Run interactively (a TTY with no feature flags) to be prompted for these.");
+}
+function printNextSteps(kind, projectName, inPlace, installed, features) {
   console.log("");
   console.log("Next steps:");
   if (!inPlace)
     console.log(`  cd ${projectName}`);
-  if (!installed)
-    console.log(kind === "e3" ? "  npm run setup" : "  npm install");
+  if (!installed) {
+    if (kind === "e3")
+      console.log(features["runner:east-py"] === false ? "  npm install" : "  npm run setup");
+    else
+      console.log("  npm install");
+  }
   console.log(kind === "e3" ? "  npm run start" : "  npm run test");
 }
 
 // src/index.ts
-runCreateCli("east", import.meta.url);
+await runCreateCli("east", import.meta.url);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@elaraai/create-east",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Scaffold a new East project (AGPL-3.0, Node-only): npm create @elaraai/east",
   "type": "module",
   "bin": {
-    "create-east": "./dist/index.js"
+    "create-east": "./bin/create-east.mjs"
   },
   "files": [
+    "bin",
     "dist",
     "templates"
   ],

package/templates/east/eslint.config.js

@@ -1,5 +1,6 @@
 import tseslint from "@typescript-eslint/eslint-plugin";
 import tsparser from "@typescript-eslint/parser";
+import east from "@elaraai/eslint-plugin-east";
 
 export default [
   { ignores: ["dist/", "node_modules/"] },
@@ -7,9 +8,16 @@ export default [
     files: ["src/**/*.ts"],
     languageOptions: {
       parser: tsparser,
-      parserOptions: { ecmaVersion: "latest", sourceType: "module" },
+      // Type-aware linting: the East rules read the TypeScript program, so the
+      // parser must build it (`projectService` discovers the nearest tsconfig).
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
     },
-    plugins: { "@typescript-eslint": tseslint },
-    rules: {},
+    plugins: { "@typescript-eslint": tseslint, east },
+    // One rule runs the whole East idiom diagnostic set (prefer some()/none, no
+    // hand-rolled variants, no $.let in an expression, etc.).
+    rules: { "east/east-rules": "warn" },
   },
 ];

package/templates/east/package.json

@@ -17,11 +17,14 @@
     "@elaraai/east-node-io": "workspace:*"
   },
   "devDependencies": {
+    "@elaraai/east-node-cli": "workspace:*",
     "@types/node": "^22",
     "typescript": "^5",
     "eslint": "^9",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
+    "@elaraai/eslint-plugin-east": "workspace:*",
+    "@elaraai/tsserver-plugin-east": "workspace:*",
     "rimraf": "^6"
   },
   "engines": { "node": ">=22" }

package/templates/east/template.json

@@ -0,0 +1,19 @@
+{
+  "features": {
+    "eslint": {
+      "default": true,
+      "files": ["eslint.config.js"],
+      "scripts": ["lint"],
+      "devDependencies": [
+        "eslint",
+        "@typescript-eslint/eslint-plugin",
+        "@typescript-eslint/parser",
+        "@elaraai/eslint-plugin-east"
+      ]
+    },
+    "editor-diagnostics": {
+      "default": true,
+      "devDependencies": ["@elaraai/tsserver-plugin-east"]
+    }
+  }
+}

package/templates/east/tsconfig.json

@@ -19,6 +19,7 @@
     "moduleDetection": "force",
     "skipLibCheck": true,
     "noErrorTruncation": true,
-    "incremental": true
+    "incremental": true,
+    "plugins": [{ "name": "@elaraai/tsserver-plugin-east" }]
   }
 }