@canonical/summon-package 0.1.0

package/src/__tests__/generators.test.ts

@@ -0,0 +1,295 @@
+/**
+ * Tests for summon-package generator
+ */
+
+import { dryRun } from "@canonical/summon";
+import { describe, expect, it } from "vitest";
+import { generator } from "../package/index.js";
+import {
+  createTemplateContext,
+  getEntryPoints,
+  getLicense,
+  getRuleset,
+  type MonorepoInfo,
+  type PackageAnswers,
+  validatePackageName,
+} from "../shared/index.js";
+
+// =============================================================================
+// Shared Utilities Tests
+// =============================================================================
+
+describe("validatePackageName", () => {
+  it("accepts valid package names", () => {
+    expect(validatePackageName("my-package")).toBe(true);
+    expect(validatePackageName("package")).toBe(true);
+    expect(validatePackageName("my-cool-package")).toBe(true);
+    expect(validatePackageName("pkg123")).toBe(true);
+    expect(validatePackageName("a")).toBe(true);
+  });
+
+  it("rejects invalid package names", () => {
+    expect(validatePackageName("")).not.toBe(true);
+    expect(validatePackageName("-package")).not.toBe(true);
+    expect(validatePackageName("package-")).not.toBe(true);
+    expect(validatePackageName("My-Package")).not.toBe(true);
+    expect(validatePackageName("my_package")).not.toBe(true);
+  });
+
+  it("strips @canonical/ prefix for validation", () => {
+    expect(validatePackageName("@canonical/my-package")).toBe(true);
+  });
+});
+
+describe("getLicense", () => {
+  it("returns GPL-3.0 for tool-ts", () => {
+    expect(getLicense("tool-ts")).toBe("GPL-3.0");
+  });
+
+  it("returns LGPL-3.0 for library", () => {
+    expect(getLicense("library")).toBe("LGPL-3.0");
+  });
+
+  it("returns LGPL-3.0 for css", () => {
+    expect(getLicense("css")).toBe("LGPL-3.0");
+  });
+});
+
+describe("getEntryPoints", () => {
+  it("returns src/ paths for tool-ts", () => {
+    const entry = getEntryPoints("tool-ts");
+    expect(entry.module).toBe("src/index.ts");
+    expect(entry.types).toBe("src/index.ts");
+    expect(entry.files).toContain("src");
+    expect(entry.needsBuild).toBe(false);
+  });
+
+  it("returns dist/ paths for library", () => {
+    const entry = getEntryPoints("library");
+    expect(entry.module).toBe("dist/esm/index.js");
+    expect(entry.types).toBe("dist/types/index.d.ts");
+    expect(entry.files).toContain("dist");
+    expect(entry.needsBuild).toBe(true);
+  });
+
+  it("returns src/index.css for css packages", () => {
+    const entry = getEntryPoints("css");
+    expect(entry.module).toBe("src/index.css");
+    expect(entry.types).toBeNull();
+    expect(entry.files).toContain("src");
+    expect(entry.needsBuild).toBe(false);
+  });
+});
+
+describe("getRuleset", () => {
+  it("returns package-react when withReact is true", () => {
+    expect(getRuleset("tool-ts", true)).toBe("package-react");
+    expect(getRuleset("library", true)).toBe("package-react");
+  });
+
+  it("returns package type when withReact is false", () => {
+    expect(getRuleset("tool-ts", false)).toBe("tool-ts");
+    expect(getRuleset("library", false)).toBe("library");
+  });
+
+  it("returns base for css packages", () => {
+    expect(getRuleset("css", false)).toBe("base");
+  });
+});
+
+describe("createTemplateContext", () => {
+  const baseAnswers: PackageAnswers = {
+    name: "@canonical/test-pkg",
+    type: "tool-ts",
+    description: "Test package",
+    withReact: false,
+    withStorybook: false,
+    withCli: false,
+    runInstall: false,
+  };
+
+  it("creates context with monorepo version", () => {
+    const monorepoInfo: MonorepoInfo = { isMonorepo: true, version: "1.2.3" };
+    const ctx = createTemplateContext(baseAnswers, monorepoInfo);
+
+    expect(ctx.name).toBe("@canonical/test-pkg");
+    expect(ctx.shortName).toBe("test-pkg");
+    expect(ctx.version).toBe("1.2.3");
+    expect(ctx.license).toBe("GPL-3.0");
+  });
+
+  it("creates context with default version when not in monorepo", () => {
+    const monorepoInfo: MonorepoInfo = { isMonorepo: false };
+    const ctx = createTemplateContext(baseAnswers, monorepoInfo);
+
+    expect(ctx.version).toBe("0.1.0");
+  });
+
+  it("handles unscoped package names", () => {
+    const unscopedAnswers: PackageAnswers = {
+      ...baseAnswers,
+      name: "my-package",
+    };
+    const monorepoInfo: MonorepoInfo = { isMonorepo: false };
+    const ctx = createTemplateContext(unscopedAnswers, monorepoInfo);
+
+    expect(ctx.name).toBe("my-package");
+    expect(ctx.shortName).toBe("my-package");
+  });
+
+  it("sets correct entry points for tool-ts", () => {
+    const monorepoInfo: MonorepoInfo = { isMonorepo: false };
+    const ctx = createTemplateContext(baseAnswers, monorepoInfo);
+
+    expect(ctx.module).toBe("src/index.ts");
+    expect(ctx.types).toBe("src/index.ts");
+    expect(ctx.needsBuild).toBe(false);
+  });
+
+  it("sets correct entry points for library", () => {
+    const answers: PackageAnswers = { ...baseAnswers, type: "library" };
+    const monorepoInfo: MonorepoInfo = { isMonorepo: false };
+    const ctx = createTemplateContext(answers, monorepoInfo);
+
+    expect(ctx.module).toBe("dist/esm/index.js");
+    expect(ctx.types).toBe("dist/types/index.d.ts");
+    expect(ctx.license).toBe("LGPL-3.0");
+    expect(ctx.needsBuild).toBe(true);
+  });
+
+  it("sets correct entry points for css", () => {
+    const answers: PackageAnswers = { ...baseAnswers, type: "css" };
+    const monorepoInfo: MonorepoInfo = { isMonorepo: false };
+    const ctx = createTemplateContext(answers, monorepoInfo);
+
+    expect(ctx.module).toBe("src/index.css");
+    expect(ctx.types).toBeNull();
+    expect(ctx.license).toBe("LGPL-3.0");
+    expect(ctx.needsBuild).toBe(false);
+  });
+});
+
+// =============================================================================
+// Generator Dry-Run Tests
+// =============================================================================
+
+describe("package generator", () => {
+  it("has correct meta information", () => {
+    expect(generator.meta.name).toBe("package");
+    expect(generator.meta.version).toBe("0.1.0");
+    expect(generator.meta.description).toBeDefined();
+  });
+
+  it("defines required prompts", () => {
+    const promptNames = generator.prompts.map((p) => p.name);
+
+    expect(promptNames).toContain("name");
+    expect(promptNames).toContain("type");
+    expect(promptNames).toContain("description");
+    expect(promptNames).toContain("withReact");
+    expect(promptNames).toContain("withCli");
+    expect(promptNames).toContain("runInstall");
+  });
+
+  it("generates expected files for tool-ts package", () => {
+    const answers: PackageAnswers = {
+      name: "@canonical/my-tool",
+      type: "tool-ts",
+      description: "My tool",
+      withReact: false,
+      withStorybook: false,
+      withCli: false,
+      runInstall: false,
+    };
+
+    const task = generator.generate(answers);
+    const result = dryRun(task);
+
+    const writePaths = result.effects
+      .filter((e) => e._tag === "WriteFile")
+      .map((e) => (e as { path: string }).path);
+
+    // Check core files are created
+    expect(writePaths.some((p) => p.endsWith("package.json"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("tsconfig.json"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("biome.json"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("index.ts"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("README.md"))).toBe(true);
+
+    // Check CLI is NOT created when withCli is false
+    expect(writePaths.some((p) => p.endsWith("cli.ts"))).toBe(false);
+  });
+
+  it("generates CLI file when withCli is true", () => {
+    const answers: PackageAnswers = {
+      name: "@canonical/my-cli",
+      type: "tool-ts",
+      description: "My CLI",
+      withReact: false,
+      withStorybook: false,
+      withCli: true,
+      runInstall: false,
+    };
+
+    const task = generator.generate(answers);
+    const result = dryRun(task);
+
+    const writePaths = result.effects
+      .filter((e) => e._tag === "WriteFile")
+      .map((e) => (e as { path: string }).path);
+
+    expect(writePaths.some((p) => p.endsWith("cli.ts"))).toBe(true);
+  });
+
+  it("generates CSS package with index.css", () => {
+    const answers: PackageAnswers = {
+      name: "@canonical/my-styles",
+      type: "css",
+      description: "My styles",
+      withReact: false,
+      withStorybook: false,
+      withCli: false,
+      runInstall: false,
+    };
+
+    const task = generator.generate(answers);
+    const result = dryRun(task);
+
+    const writePaths = result.effects
+      .filter((e) => e._tag === "WriteFile")
+      .map((e) => (e as { path: string }).path);
+
+    // Check CSS-specific files
+    expect(writePaths.some((p) => p.endsWith("index.css"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("package.json"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("biome.json"))).toBe(true);
+    expect(writePaths.some((p) => p.endsWith("README.md"))).toBe(true);
+
+    // Check no TypeScript files for CSS package
+    expect(writePaths.some((p) => p.endsWith("index.ts"))).toBe(false);
+    expect(writePaths.some((p) => p.endsWith("tsconfig.json"))).toBe(false);
+  });
+
+  it("creates directory structure using short name", () => {
+    const answers: PackageAnswers = {
+      name: "@canonical/my-pkg",
+      type: "tool-ts",
+      description: "",
+      withReact: false,
+      withStorybook: false,
+      withCli: false,
+      runInstall: false,
+    };
+
+    const task = generator.generate(answers);
+    const result = dryRun(task);
+
+    const mkdirPaths = result.effects
+      .filter((e) => e._tag === "MakeDir")
+      .map((e) => (e as { path: string }).path);
+
+    // Directory should be the short name (without scope)
+    expect(mkdirPaths.some((p) => p === "my-pkg")).toBe(true);
+    expect(mkdirPaths.some((p) => p.endsWith("src"))).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @canonical/summon-package
+ *
+ * Package generator for Summon - scaffold new npm packages with proper configuration.
+ */
+
+import type { AnyGenerator } from "@canonical/summon";
+import { generator as packageGenerator } from "./package/index.js";
+
+export const generators: Record<string, AnyGenerator> = {
+  package: packageGenerator as unknown as AnyGenerator,
+};
+
+export default generators;

package/src/package/index.ts

@@ -0,0 +1,306 @@
+/**
+ * Package Generator
+ *
+ * Generates a new npm package with proper configuration for the pragma monorepo.
+ */
+
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  exec,
+  flatMap,
+  type GeneratorDefinition,
+  info,
+  mkdir,
+  type PromptDefinition,
+  sequence_,
+  template,
+  when,
+} from "@canonical/summon";
+
+import {
+  createTemplateContext,
+  detectMonorepo,
+  detectPackageManager,
+  getPackageShortName,
+  type PackageAnswers,
+  validatePackageName,
+} from "../shared/index.js";
+
+// =============================================================================
+// Template Paths
+// =============================================================================
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const templatesDir = path.join(__dirname, "..", "templates");
+
+const templates = {
+  packageJson: path.join(templatesDir, "package.json.ejs"),
+  tsconfig: path.join(templatesDir, "tsconfig.json.ejs"),
+  tsconfigReact: path.join(templatesDir, "tsconfig-react.json.ejs"),
+  biome: path.join(templatesDir, "biome.json.ejs"),
+  indexTs: path.join(templatesDir, "index.ts.ejs"),
+  indexCss: path.join(templatesDir, "index.css.ejs"),
+  cliTs: path.join(templatesDir, "cli.ts.ejs"),
+  readme: path.join(templatesDir, "README.md.ejs"),
+  storybookMain: path.join(templatesDir, "storybook-main.ts.ejs"),
+  storybookPreview: path.join(templatesDir, "storybook-preview.ts.ejs"),
+};
+
+// =============================================================================
+// Prompts
+// =============================================================================
+
+const prompts: PromptDefinition[] = [
+  {
+    name: "name",
+    type: "text",
+    message: "Package name:",
+    default: "@canonical/my-package",
+    validate: validatePackageName,
+    group: "Package",
+  },
+  {
+    name: "type",
+    type: "select",
+    message: "Package type:",
+    choices: [
+      {
+        label: "tool-ts - TypeScript tool (runs from src/, no build)",
+        value: "tool-ts",
+      },
+      {
+        label: "library - Publishable library (dist/ build output)",
+        value: "library",
+      },
+      {
+        label: "css - CSS package (src/index.css, no build)",
+        value: "css",
+      },
+    ],
+    default: "tool-ts",
+    group: "Package",
+  },
+  {
+    name: "description",
+    type: "text",
+    message: "Package description:",
+    default: "",
+    group: "Package",
+  },
+  {
+    name: "withReact",
+    type: "confirm",
+    message: "Include React dependencies?",
+    default: false,
+    group: "Options",
+  },
+  {
+    name: "withStorybook",
+    type: "confirm",
+    message: "Include Storybook setup?",
+    default: false,
+    group: "Options",
+  },
+  {
+    name: "withCli",
+    type: "confirm",
+    message: "Include CLI binary entry point?",
+    default: false,
+    group: "Options",
+  },
+  {
+    name: "runInstall",
+    type: "confirm",
+    message: "Run package manager install after creation?",
+    default: true,
+    group: "Post-setup",
+  },
+];
+
+// =============================================================================
+// Generator Definition
+// =============================================================================
+
+export const generator: GeneratorDefinition<PackageAnswers> = {
+  meta: {
+    name: "package",
+    description:
+      "Generate a new npm package with proper configuration for the pragma monorepo",
+    version: "0.1.0",
+    help: `Generate a new npm package with proper configuration.
+
+PACKAGE TYPES:
+  tool-ts   TypeScript tool that runs directly from src/ (no build step)
+            License: GPL-3.0, Entry: src/index.ts
+            Examples: summon, webarchitect
+
+  library   Publishable library with dist/ build output
+            License: LGPL-3.0, Entry: dist/esm/index.js
+            Examples: utils, ds-types
+
+  css       CSS-only package (no TypeScript, no build)
+            License: LGPL-3.0, Entry: src/index.css
+            Examples: styles/primitives, styles/modes
+
+OPTIONS:
+  --with-react      Add React dependencies and TypeScript React config
+  --with-storybook  Add Storybook configuration
+  --with-cli        Add CLI binary entry point (src/cli.ts)
+
+The generator auto-detects:
+  - Monorepo: Uses lerna.json version when in pragma monorepo
+  - Package manager: Detects bun/yarn/pnpm (defaults to bun)`,
+    examples: [
+      "summon package --name=@canonical/my-tool --type=tool-ts",
+      "summon package --name=@canonical/my-lib --type=library --with-react",
+      "summon package --name=@canonical/my-cli --type=tool-ts --with-cli",
+      "summon package --name=my-styles --type=css",
+      "summon package --name=@canonical/my-pkg --type=library --no-run-install",
+    ],
+  },
+
+  prompts,
+
+  generate: (answers) => {
+    const packageDir = getPackageShortName(answers.name);
+    const cwd = process.cwd();
+    const isCss = answers.type === "css";
+    const needsTs = !isCss;
+
+    return flatMap(detectMonorepo(cwd), (monorepoInfo) => {
+      const ctx = createTemplateContext(answers, monorepoInfo);
+
+      return sequence_([
+        info(`Creating package: ${answers.name}`),
+        info(`Type: ${answers.type}`),
+        when(
+          monorepoInfo.isMonorepo,
+          info(`Monorepo detected, using version: ${monorepoInfo.version}`),
+        ),
+
+        // Create directory structure
+        mkdir(packageDir),
+        mkdir(path.join(packageDir, "src")),
+
+        // Create package.json
+        template({
+          source: templates.packageJson,
+          dest: path.join(packageDir, "package.json"),
+          vars: ctx,
+        }),
+
+        // Create tsconfig.json (only for non-CSS packages)
+        when(
+          needsTs && answers.withReact,
+          template({
+            source: templates.tsconfigReact,
+            dest: path.join(packageDir, "tsconfig.json"),
+            vars: ctx,
+          }),
+        ),
+        when(
+          needsTs && !answers.withReact,
+          template({
+            source: templates.tsconfig,
+            dest: path.join(packageDir, "tsconfig.json"),
+            vars: ctx,
+          }),
+        ),
+
+        // Create biome.json
+        template({
+          source: templates.biome,
+          dest: path.join(packageDir, "biome.json"),
+          vars: ctx,
+        }),
+
+        // Create src/index.ts (for TS packages)
+        when(
+          needsTs,
+          template({
+            source: templates.indexTs,
+            dest: path.join(packageDir, "src", "index.ts"),
+            vars: ctx,
+          }),
+        ),
+
+        // Create src/index.css (for CSS packages)
+        when(
+          isCss,
+          template({
+            source: templates.indexCss,
+            dest: path.join(packageDir, "src", "index.css"),
+            vars: ctx,
+          }),
+        ),
+
+        // Create src/cli.ts (conditional, only for TS packages)
+        when(
+          needsTs && answers.withCli,
+          template({
+            source: templates.cliTs,
+            dest: path.join(packageDir, "src", "cli.ts"),
+            vars: ctx,
+          }),
+        ),
+
+        // Create README.md
+        template({
+          source: templates.readme,
+          dest: path.join(packageDir, "README.md"),
+          vars: ctx,
+        }),
+
+        // Create .storybook folder (conditional)
+        when(answers.withStorybook, mkdir(path.join(packageDir, ".storybook"))),
+        when(
+          answers.withStorybook,
+          mkdir(path.join(packageDir, "src", "assets")),
+        ),
+        when(answers.withStorybook, mkdir(path.join(packageDir, "public"))),
+        when(
+          answers.withStorybook,
+          template({
+            source: templates.storybookMain,
+            dest: path.join(packageDir, ".storybook", "main.ts"),
+            vars: ctx,
+          }),
+        ),
+        when(
+          answers.withStorybook,
+          template({
+            source: templates.storybookPreview,
+            dest: path.join(packageDir, ".storybook", "preview.ts"),
+            vars: ctx,
+          }),
+        ),
+
+        info(`Package created at ./${packageDir}`),
+
+        // Run install (conditional)
+        when(
+          answers.runInstall,
+          flatMap(detectPackageManager(cwd), (pm) => {
+            return sequence_([
+              info(`Running ${pm} install...`),
+              flatMap(exec(pm, ["install"], packageDir), () =>
+                info(`Dependencies installed successfully`),
+              ),
+            ]);
+          }),
+        ),
+
+        when(!answers.runInstall, info("Skipping install step")),
+
+        info(""),
+        info("Next steps:"),
+        info(`  cd ${packageDir}`),
+        info("  bun run check"),
+        info(""),
+      ]);
+    });
+  },
+};
+
+export default generator;