create-lumen 2.0.0-alpha.0 → 2.0.0-alpha.2

package/src/main.js

@@ -17,6 +17,7 @@ import { installAllDeps } from "@/dependencies.js";
 import { generateReadme } from "@/readme.js";
 import { runProjectFormat } from "@/format.js";
 import { emitManifest } from "@/manifest/emit.js";
+import { emitAgentContext } from "@/agent-context.js";
 
 import { parseCliArgs, loadManifestSource, manifestToResponses, PRESETS } from "@/cli-args.js";
 
@@ -47,6 +48,7 @@ export async function main(options = {}) {
     projectName: nameArg,
     manifest: manifestSource,
     template: templateName,
+    arch: archArg,
   } = options;
   const pkg = getPkgManager();
 
@@ -92,7 +94,7 @@ export async function main(options = {}) {
       ...preset,
     };
   } else {
-    responses = await getUserInputs(projectName, { quickSetup });
+    responses = await getUserInputs(projectName, { quickSetup, initialArch: archArg });
   }
 
   const projectPath = path.resolve(CURRENT_DIR, projectName);
@@ -135,7 +137,7 @@ export async function main(options = {}) {
   // 7. Inject architecture templates
   const archSpin = spinner();
   archSpin.start(
-    `Setting up ${responses.architecture === "feature-based" ? "feature-based" : "type-based"} architecture...`
+    `Setting up ${responses.architecture} architecture...`
   );
   try {
     await injectArchitecture(
@@ -193,11 +195,9 @@ export async function main(options = {}) {
   // 10. CSS framework setup
   const cssSpin = spinner();
   const cssLabel =
-    responses.cssFramework === "none"
-      ? "CSS reset"
-      : responses.cssFramework === "tailwind"
+    responses.cssFramework === "tailwind"
       ? "Tailwind CSS"
-      : "Bootstrap";
+      : "CSS reset";
   if (responses.cssFramework !== "none") {
     cssSpin.start(`Setting up ${cssLabel}...`);
   }
@@ -247,6 +247,19 @@ export async function main(options = {}) {
     throw err;
   }
 
+  // 12.7 Emit .lumen agent context dir (only when agentDocs is enabled)
+  if (responses.agentDocs === true || responses._manifestSource?.agentDocs === true) {
+    const agentSpin = spinner();
+    agentSpin.start("Writing .lumen agent context...");
+    try {
+      await emitAgentContext(projectPath, responses._manifestSource ?? responses);
+      agentSpin.stop(chalk.green(".lumen agent context written."));
+    } catch (err) {
+      agentSpin.stop(chalk.red("Failed to write .lumen agent context."));
+      throw err;
+    }
+  }
+
   // 13. Generate README.md + LICENSE (if requested)
   if (responses.readme) {
     const readmeSpin = spinner();
@@ -276,7 +289,7 @@ export async function main(options = {}) {
   log.step(chalk.green("\nProject setup complete!"));
   log.message(
     chalk.gray(
-      `  Architecture: ${responses.architecture === "feature-based" ? "Feature-based" : "Type-based"}`
+      `  Architecture: ${responses.architecture}`
     )
   );
 

package/src/manifest/emit.js

@@ -1,8 +1,43 @@
 import { promises as fsp } from "fs";
 import path from "path";
-import { parseManifest, SCHEMA_URL, MANIFEST_VERSION } from "./schema.js";
+import { parseManifest, SCHEMA_URL, MANIFEST_VERSION, HARNESS_DEFAULT_COMMANDS } from "./schema.js";
 import { resolvePaths } from "./paths.js";
 
+const LINT_COMMANDS = {
+  eslint: "eslint .",
+  oxlint: "oxlint .",
+  biome: "biome check .",
+};
+
+const FORMAT_COMMANDS = {
+  prettier: "prettier --check .",
+  oxfmt: "oxfmt --check .",
+};
+
+/**
+ * Build default harness commands from tooling choices.
+ * Skips lint/format when tooling is "none"; skips types when language is not "ts".
+ * Test + build are always included so commands.length >= 1.
+ * @param {{ linter?: string, formatter?: string, language?: string }} tooling
+ * @returns {Array<{ name: string, command: string, required: boolean }>}
+ */
+export function defaultHarnessCommands(tooling = {}) {
+  const { linter = "none", formatter = "none", language = "ts" } = tooling;
+  const commands = [];
+  if (linter && linter !== "none" && LINT_COMMANDS[linter]) {
+    commands.push({ name: "lint", command: LINT_COMMANDS[linter], required: true });
+  }
+  if (formatter && formatter !== "none" && FORMAT_COMMANDS[formatter]) {
+    commands.push({ name: "format", command: FORMAT_COMMANDS[formatter], required: true });
+  }
+  if (language === "ts") {
+    commands.push({ name: "types", command: "tsc -b", required: true });
+  }
+  commands.push({ name: "test", command: "vitest run", required: true });
+  commands.push({ name: "build", command: "npm run build", required: true });
+  return commands.length > 0 ? commands : [...HARNESS_DEFAULT_COMMANDS];
+}
+
 /**
  * Build an ordered manifest v2 object from scaffolder responses.
  * Stable key ordering for byte-determinism.
@@ -35,9 +70,14 @@ export function buildManifest(responses, opts = {}) {
     engine: responses.cssFramework || "tailwind",
   };
 
-  const rawArch = responses.architecture || "feature-based";
+  const rawArch =
+    responses.architecturePreset || responses.architecture || "feature-based";
+  const normalizedArch = rawArch === "component-based" ? "type-based" : rawArch;
   const architecture = {
-    type: rawArch === "component-based" ? "type-based" : rawArch,
+    preset: normalizedArch,
+    type: normalizedArch,
+    validation:
+      responses.architectureValidation || responses.validation || "strict",
   };
 
   const ui = {
@@ -59,12 +99,17 @@ export function buildManifest(responses, opts = {}) {
     formatter: responses.formatter || "none",
   };
 
+  const harness = responses.harness ?? {
+    commands: defaultHarnessCommands(tooling),
+  };
+
   const manifest = {
     $schema: SCHEMA_URL,
     manifestVersion: MANIFEST_VERSION,
     framework,
     styling,
     architecture,
+    harness,
     ui,
     docs,
     paths,
@@ -83,6 +128,7 @@ export function buildManifest(responses, opts = {}) {
     "framework",
     "styling",
     "architecture",
+    "harness",
     "ui",
     "docs",
     "paths",

package/src/manifest/schema.js

@@ -12,8 +12,12 @@ export const FRAMEWORK_VARIANTS = ["vite", "app-router", "pages-router"];
 export const FRAMEWORK_BUNDLERS = ["turbopack", "webpack"];
 export const FRAMEWORK_ADAPTERS = ["node", "vercel", "cloudflare", "static"];
 
-export const STYLING_ENGINES = ["tailwind", "bootstrap", "none"];
-export const ARCHITECTURE_TYPES = ["feature-based", "type-based", "hybrid", "none"];
+export const STYLING_ENGINES = ["tailwind", "none"];
+export const ARCHITECTURE_PRESETS = ["feature-based", "type-based", "hybrid", "none"];
+// Legacy alias: docs used architecture.type, canonical is architecture.preset.
+// Keep both in sync; parseManifest normalizes to expose both keys.
+export const ARCHITECTURE_TYPES = ARCHITECTURE_PRESETS;
+export const ARCHITECTURE_VALIDATIONS = ["strict", "relaxed", "none"];
 export const UI_KITS = ["shadcn", "none"];
 export const DOCS_LANGUAGES = ["en", "es"];
 export const TOOLING_LANGUAGES = ["ts", "js"];
@@ -40,7 +44,49 @@ const stylingSchema = z
 
 const architectureSchema = z
   .object({
-    type: z.enum(ARCHITECTURE_TYPES),
+    // Canonical key per docs/manifest-v2.md; legacy `type` kept as alias.
+    preset: z.enum(ARCHITECTURE_PRESETS).optional(),
+    type: z.enum(ARCHITECTURE_TYPES).optional(),
+    validation: z.enum(ARCHITECTURE_VALIDATIONS).optional().default("strict"),
+  })
+  .strict()
+  .superRefine((val, ctx) => {
+    if (!val.preset && !val.type) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["preset"],
+        message: 'architecture must define "preset" or legacy "type"',
+      });
+    }
+    if (val.preset && val.type && val.preset !== val.type) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["preset"],
+        message: `architecture.preset "${val.preset}" must match architecture.type "${val.type}"`,
+      });
+    }
+  });
+
+export const HARNESS_DEFAULT_COMMANDS = [
+  { name: "lint", command: "oxlint .", required: true },
+  { name: "format", command: "oxfmt --check .", required: true },
+  { name: "types", command: "tsc -b", required: true },
+  { name: "test", command: "vitest run", required: true },
+  { name: "build", command: "npm run build", required: true },
+];
+
+const harnessCommandSchema = z
+  .object({
+    name: z.string().min(1),
+    command: z.string().min(1),
+    required: z.boolean().optional().default(true),
+    description: z.string().optional(),
+  })
+  .strict();
+
+const harnessSchema = z
+  .object({
+    commands: z.array(harnessCommandSchema).min(1),
   })
   .strict();
 
@@ -85,6 +131,7 @@ export const manifestSchemaV2 = z
     framework: frameworkSchema,
     styling: stylingSchema,
     architecture: architectureSchema,
+    harness: harnessSchema.optional(),
     ui: uiSchema,
     docs: docsSchema,
     paths: pathsSchema,
@@ -130,16 +177,17 @@ export const manifestSchemaV2 = z
       });
     }
 
-    // architecture scoping per framework (#34)
+    // architecture scoping per framework (#34) — canonical `preset`, legacy `type` fallback
+    const archValue = architecture.preset ?? architecture.type;
     const allowedByFramework =
       framework.name === "react"
         ? ["feature-based", "type-based", "none"]
         : ["feature-based", "hybrid", "none"];
-    if (!allowedByFramework.includes(architecture.type)) {
+    if (!allowedByFramework.includes(archValue)) {
       ctx.addIssue({
         code: "custom",
         path: ["architecture", "type"],
-        message: `architecture.type "${architecture.type}" is not valid for framework "${framework.name}" (allowed: ${allowedByFramework.join(", ")})`,
+        message: `architecture.type "${archValue}" is not valid for framework "${framework.name}" (allowed: ${allowedByFramework.join(", ")})`,
       });
     }
 
@@ -205,7 +253,17 @@ export function parseManifest(raw) {
     err.cause = result.error;
     throw err;
   }
-  return result.data;
+  // Normalize: always expose architecture.preset + architecture.type (synced)
+  // + architecture.validation default, for backward/forward compat.
+  const data = result.data;
+  const preset = data.architecture.preset ?? data.architecture.type;
+  const type = data.architecture.type ?? data.architecture.preset;
+  data.architecture = {
+    preset,
+    type,
+    validation: data.architecture.validation ?? "strict",
+  };
+  return data;
 }
 
 // Re-export type helper for JSDoc (z.infer)