drimion 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1045 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command7 } from "commander";
+
+// src/cli/commands/generate.ts
+import path3 from "path";
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/cli/core/generator.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+import fs2 from "fs-extra";
+import Handlebars from "handlebars";
+
+// src/cli/utils/naming.ts
+function tokenize(input3) {
+  return input3.trim().replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/[^\w\s]/g, "").toLowerCase().split(/\s+/).filter(Boolean);
+}
+function toPascalCase(input3) {
+  const tokens = tokenize(input3);
+  if (tokens.length === 0) {
+    throw new Error("Invalid name: cannot normalize empty input");
+  }
+  return tokens.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toKebabCase(tokens) {
+  return tokens.join("-");
+}
+function toSnakeCase(tokens) {
+  return tokens.join("_");
+}
+function toPascalFile(tokens) {
+  return tokens.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function toFileName(className, type, convention) {
+  if (!className) throw new Error("className is required");
+  if (!type) throw new Error("type is required");
+  let base;
+  let suffix;
+  switch (convention) {
+    case "kebab-case":
+      base = toKebabCase(tokenize(className));
+      suffix = toKebabCase(tokenize(type));
+      break;
+    case "snake_case":
+      base = toSnakeCase(tokenize(className));
+      suffix = toSnakeCase(tokenize(type));
+      break;
+    case "PascalCase":
+      base = toPascalFile(tokenize(className));
+      suffix = toPascalFile(tokenize(type));
+      break;
+    default:
+      throw new Error(`Unsupported naming convention: ${convention}`);
+  }
+  return `${base}.${suffix}.ts`;
+}
+
+// src/cli/core/resolver.ts
+import path from "path";
+import { pathToFileURL } from "url";
+import fs from "fs-extra";
+
+// src/cli/utils/type-map.ts
+var TYPE_MAP = {
+  entity: "entity",
+  "value-object": "valueObject",
+  aggregate: "aggregate",
+  repository: "repository",
+  "use-case": "usecase"
+};
+function toConfigKey(type) {
+  return TYPE_MAP[type];
+}
+
+// src/cli/core/resolver.ts
+var Resolver = class _Resolver {
+  static async loadConfig(cwd = process.cwd()) {
+    const configPath = path.resolve(cwd, "drimion.config.ts");
+    const exists = await fs.pathExists(configPath);
+    if (!exists) {
+      throw new Error(
+        "Config file `drimion.config.ts` not found. Run `npx drimion init` first."
+      );
+    }
+    try {
+      const module = await import(pathToFileURL(configPath).href);
+      const config = module.default;
+      if (!config?.drimion) {
+        throw new Error("Invalid config: missing `drimion` key");
+      }
+      if (!config.drimion.targets) {
+        throw new Error("Invalid config: missing `drimion.targets`");
+      }
+      return config;
+    } catch (err) {
+      throw new Error(
+        `Failed to load drimion.config.ts: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  static resolveTarget(type, target, config, cwd = process.cwd()) {
+    const key = toConfigKey(type);
+    const typeTargets = config.drimion.targets?.[key];
+    if (!typeTargets) {
+      throw new Error(`No targets defined for type "${type}"`);
+    }
+    const targetPath = typeTargets[target];
+    if (!targetPath) {
+      throw new Error(
+        `Target "${target}" not found for type "${type}" in config`
+      );
+    }
+    return path.resolve(cwd, targetPath);
+  }
+  static resolveLocation(location, cwd = process.cwd()) {
+    if (!location || location.trim() === "") {
+      throw new Error("Invalid location: cannot be empty");
+    }
+    return path.resolve(cwd, location);
+  }
+  static resolveOutputPath(opts, config, cwd = process.cwd()) {
+    const { type, target, location } = opts;
+    if (!type) {
+      throw new Error("Generator type is required");
+    }
+    if (location) {
+      return _Resolver.resolveLocation(location, cwd);
+    }
+    if (target) {
+      return _Resolver.resolveTarget(
+        type,
+        target,
+        config,
+        cwd
+      );
+    }
+    throw new Error("Either `target` or `location` must be provided");
+  }
+  static async ensureDir(dir) {
+    await fs.ensureDir(dir);
+  }
+  static resolveCorePath(config, cwd = process.cwd()) {
+    if (!config.drimion.corePath) {
+      throw new Error("Invalid config: missing `drimion.corePath`");
+    }
+    return path.resolve(cwd, config.drimion.corePath);
+  }
+};
+
+// src/cli/core/generator.ts
+var Generator = class _Generator {
+  static async generate(opts) {
+    const className = toPascalCase(opts.name);
+    const fileName = toFileName(
+      className,
+      opts.type,
+      opts.config.drimion.naming
+    );
+    const templatePath = _Generator.resolveTemplatePath(opts.type);
+    const templateContent = await _Generator.loadTemplate(templatePath);
+    const compiled = _Generator.compileTemplate(templateContent);
+    const output = compiled(
+      _Generator.buildTemplateContext({
+        className,
+        fileName,
+        type: opts.type,
+        config: opts.config
+      })
+    );
+    const fullOutputPath = path2.join(opts.outputPath, fileName);
+    await Resolver.ensureDir(opts.outputPath);
+    await _Generator.writeFile(fullOutputPath, output);
+  }
+  static resolveTemplatePath(type) {
+    const __dirname = path2.dirname(fileURLToPath(import.meta.url));
+    const templateFile = `${type}.ts.hbs`;
+    return path2.resolve(__dirname, "..", "templates", templateFile);
+  }
+  static async loadTemplate(filePath) {
+    const exists = await fs2.pathExists(filePath);
+    if (!exists) {
+      throw new Error(`Template not found: ${filePath}`);
+    }
+    return fs2.readFile(filePath, "utf-8");
+  }
+  static compileTemplate(template) {
+    return Handlebars.compile(template, {
+      noEscape: true
+    });
+  }
+  static buildTemplateContext(opts) {
+    return {
+      className: opts.className,
+      fileName: opts.fileName,
+      type: opts.type,
+      importAlias: opts.config.drimion.importAlias,
+      lowerName: opts.className.toLowerCase()
+    };
+  }
+  static async writeFile(filePath, content) {
+    const exists = await fs2.pathExists(filePath);
+    if (exists) {
+      throw new Error(`File already exists: ${filePath}`);
+    }
+    await fs2.writeFile(filePath, content, "utf-8");
+  }
+};
+
+// src/cli/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/cli/utils/package-manager.ts
+import { createRequire } from "module";
+function resolvePackageManager() {
+  if (true) {
+    return {
+      __PKG_NAME__: "drimion",
+      __PKG_VERSION__: "0.1.0",
+      __PKG_REPOSITORY__: "git+https://github.com/bramadl/drimion.git"
+    };
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const locations = ["../../package.json", "../../../package.json"];
+    for (const loc of locations) {
+      try {
+        const pkg = require2(loc);
+        const repoUrl = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url ?? "";
+        return {
+          __PKG_NAME__: pkg.name,
+          __PKG_VERSION__: pkg.version,
+          __PKG_REPOSITORY__: repoUrl
+        };
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return {
+    __PKG_NAME__: "drimion",
+    __PKG_VERSION__: "?",
+    __PKG_REPOSITORY__: ""
+  };
+}
+
+// src/cli/utils/logger.ts
+var { __PKG_NAME__: __PKG_NAME__2, __PKG_VERSION__: __PKG_VERSION__2, __PKG_REPOSITORY__: __PKG_REPOSITORY__2 } = resolvePackageManager();
+var logger = {
+  banner(info = false) {
+    const title = `  @${__PKG_NAME__2}/cli  \u2022  v${__PKG_VERSION__2}  `;
+    const border = "\u2500".repeat(title.length);
+    console.log();
+    console.log(chalk.dim(`  \u256D${border}\u256E`));
+    console.log(chalk.bold.cyan(`  \u2502${title}\u2502`));
+    console.log(chalk.dim(`  \u2570${border}\u256F`));
+    if (info) {
+      console.log();
+      console.log(
+        chalk.cyan.bold(
+          `  ${__PKG_NAME__2} - Headless DDD primitives CLI for TypeScript`
+        )
+      );
+    }
+    console.log();
+  },
+  info(message) {
+    console.log(chalk.cyan(`  ${message}`));
+  },
+  success(message) {
+    console.log(chalk.green(`  \u2714 ${message}`));
+  },
+  warn(message) {
+    console.log(chalk.yellow(`  \u26A0 ${message}`));
+  },
+  error(message) {
+    console.error(chalk.red(`  \u2716 ${message}`));
+  },
+  /**
+   * Print an indented block of lines — used for "next steps", summaries, etc.
+   * Each line is already pre-formatted by the caller (can include chalk).
+   */
+  hint(lines) {
+    for (const line of lines) {
+      console.log(`  ${line}`);
+    }
+  },
+  divider() {
+    console.log(chalk.dim(`  ${"\u2500".repeat(42)}`));
+  },
+  cancelled() {
+    console.log(chalk.yellow("  \u25CB Cancelled."));
+  },
+  spinner(message) {
+    return ora({
+      text: message,
+      spinner: "dots",
+      indent: 2
+    }).start();
+  }
+};
+
+// src/cli/utils/prompts.ts
+import { input, select } from "@inquirer/prompts";
+var prompts = {
+  async selectGenerator() {
+    return select({
+      message: "What do you want to generate?",
+      choices: [
+        { value: "entity" },
+        { value: "value-object" },
+        { value: "aggregate" },
+        { value: "repository" },
+        { value: "use-case" }
+      ]
+    });
+  },
+  async inputName() {
+    return input({
+      message: "Name:",
+      validate(value) {
+        if (!value || value.trim() === "") return "Name is required";
+        return true;
+      }
+    });
+  },
+  async selectTarget(targets) {
+    const keys = Object.keys(targets || {});
+    if (keys.length === 0) return null;
+    const result = await select({
+      message: "Where should this be created?",
+      choices: [...keys, "manual"].map((k) => ({ value: k }))
+    });
+    return result === "manual" ? null : result;
+  },
+  async inputLocation() {
+    return input({
+      message: "Enter output path:",
+      validate(value) {
+        if (!value || value.trim() === "") return "Location is required";
+        return true;
+      }
+    });
+  }
+};
+
+// src/cli/commands/generate.ts
+function stripLeadingEquals(value) {
+  return value.startsWith("=") ? value.slice(1) : value;
+}
+var generateCommand = new Command("generate").description("Generate a DDD building block from a template").argument("[type]", "Generator type (entity, value-object, etc)").option("-n, --name <name>", "Name of the class").option("-t, --target <target>", "Target from config").option("-l, --location <location>", "Manual output path").action(async (typeArg, options) => {
+  logger.banner();
+  let spinner;
+  const isInteractive = !typeArg || !options.name || !options.target && !options.location;
+  try {
+    const config = await Resolver.loadConfig();
+    const type = typeArg || await prompts.selectGenerator();
+    const rawName = options.name ? stripLeadingEquals(options.name) : await prompts.inputName();
+    const normalized = toPascalCase(rawName);
+    let outputPath;
+    if (options.location) {
+      outputPath = Resolver.resolveLocation(
+        stripLeadingEquals(options.location)
+      );
+    } else if (options.target) {
+      outputPath = Resolver.resolveTarget(
+        type,
+        stripLeadingEquals(options.target),
+        config
+      );
+    } else {
+      const configKey = toConfigKey(type);
+      const targets = config.drimion.targets?.[configKey] || {};
+      const target = await prompts.selectTarget(targets);
+      if (target) {
+        outputPath = Resolver.resolveTarget(type, target, config);
+      } else {
+        const location = await prompts.inputLocation();
+        outputPath = Resolver.resolveLocation(location);
+      }
+    }
+    if (isInteractive) console.log();
+    spinner = logger.spinner("Generating...");
+    await Generator.generate({
+      type,
+      name: normalized,
+      outputPath,
+      config
+    });
+    spinner.stop();
+    const fileName = toFileName(normalized, type, config.drimion.naming);
+    const fullPath = path3.join(outputPath, fileName);
+    const relativePath = path3.relative(process.cwd(), fullPath);
+    logger.divider();
+    console.log();
+    logger.hint([
+      `${chalk2.green("\u2714")} ${chalk2.bold(normalized)} generated successfully.`,
+      "",
+      `  ${chalk2.dim("type")}    ${chalk2.cyan(type)}`,
+      `  ${chalk2.dim("file")}    ${chalk2.white(relativePath)}`
+    ]);
+    console.log();
+  } catch (err) {
+    spinner?.stop();
+    if (err instanceof Error && err.message.includes("force closed the prompt")) {
+      console.log();
+      logger.cancelled();
+      console.log();
+      process.exit(0);
+    }
+    logger.divider();
+    console.log();
+    if (err instanceof Error && err.message.startsWith("File already exists:")) {
+      const absolutePath = err.message.replace("File already exists: ", "");
+      const relativePath = path3.relative(process.cwd(), absolutePath);
+      logger.hint([
+        chalk2.dim(
+          "Already generated? Edit the file directly, or delete it to regenerate."
+        )
+      ]);
+      logger.error(`File already exists: ${relativePath}`);
+    } else {
+      logger.error(err instanceof Error ? err.message : String(err));
+    }
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/info.ts
+import chalk3 from "chalk";
+import { Command as Command2 } from "commander";
+var { __PKG_REPOSITORY__: __PKG_REPOSITORY__3 } = resolvePackageManager();
+var COMMANDS = [
+  {
+    name: "init",
+    description: "Initialize drimion in your project.",
+    flags: [
+      {
+        flag: "-y, --yes",
+        description: "Skip all prompts and use defaults"
+      }
+    ],
+    examples: ["npx drimion init", "npx drimion init -y"]
+  },
+  {
+    name: "generate",
+    description: "Generate a DDD building block from a template. Runs interactively if flags are omitted.",
+    arguments: "[type]  entity | value-object | aggregate | repository | use-case",
+    flags: [
+      {
+        flag: "-n, --name <name>",
+        description: "Class name (auto-normalized to PascalCase)"
+      },
+      {
+        flag: "-t, --target <target>",
+        description: "Predefined target path from drimion.config.ts"
+      },
+      { flag: "-l, --location <path>", description: "Manual output directory" }
+    ],
+    examples: [
+      "npx drimion generate",
+      "npx drimion generate entity -n User -t user",
+      "npx drimion generate value-object -n Email -l src/modules/user/domain"
+    ]
+  },
+  {
+    name: "list",
+    description: "List all available generators and the targets configured in drimion.config.ts.",
+    examples: ["npx drimion list"]
+  },
+  {
+    name: "sync",
+    description: "Update the library kernel to the latest version. Offers backup before overwriting.",
+    flags: [
+      {
+        flag: "-f, --force",
+        description: "Overwrite everything \u2014 no prompts, no backup"
+      }
+    ],
+    examples: ["npx drimion sync", "npx drimion sync -f"]
+  },
+  {
+    name: "uninstall",
+    description: "Remove the library kernel and drimion.config.ts from your project.",
+    examples: ["npx drimion uninstall"]
+  },
+  {
+    name: "info",
+    description: "Display CLI information and command reference.",
+    examples: ["npx drimion info"]
+  }
+];
+function printCommand(cmd, isLast) {
+  const connector = isLast ? "\u2570\u2500" : "\u251C\u2500";
+  const indent = isLast ? "   " : "\u2502  ";
+  console.log(`  ${chalk3.dim(connector)} ${chalk3.cyan.bold(cmd.name)}`);
+  console.log(`  ${chalk3.dim(indent)}  ${chalk3.white(cmd.description)}`);
+  if (cmd.arguments) {
+    console.log();
+    console.log(`  ${chalk3.dim(indent)}  ${chalk3.dim("argument")}`);
+    console.log(
+      `  ${chalk3.dim(indent)}  ${chalk3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`
+    );
+    console.log(`  ${chalk3.dim(indent)}  ${chalk3.white(cmd.arguments)}`);
+  }
+  if (cmd.flags && cmd.flags.length > 0) {
+    console.log();
+    console.log(`  ${chalk3.dim(indent)}  ${chalk3.dim("flags")}`);
+    console.log(
+      `  ${chalk3.dim(indent)}  ${chalk3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`
+    );
+    for (const { flag, description } of cmd.flags) {
+      const flagCol = chalk3.yellow(flag.padEnd(26));
+      console.log(
+        `  ${chalk3.dim(indent)}  ${flagCol}${chalk3.dim(description)}`
+      );
+    }
+  }
+  console.log();
+  console.log(`  ${chalk3.dim(indent)}  ${chalk3.dim("examples")}`);
+  console.log(
+    `  ${chalk3.dim(indent)}  ${chalk3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`
+  );
+  for (const example of cmd.examples) {
+    console.log(
+      `  ${chalk3.dim(indent)}  ${chalk3.dim("$")} ${chalk3.white(example)}`
+    );
+  }
+  if (!isLast) console.log(`  ${chalk3.dim("\u2502")}`);
+}
+var infoCommand = new Command2("info").description("Display CLI information and command reference").action(() => {
+  logger.banner(true);
+  if (__PKG_REPOSITORY__3) {
+    logger.hint([chalk3.bold("Docs & Source")]);
+    logger.hint([
+      `GitHub Repo  ${chalk3.dim("\u2192")}  ${chalk3.cyan(
+        __PKG_REPOSITORY__3.replace(/^git\+/, "").replace(/\.git$/, "")
+      )}`
+    ]);
+    console.log();
+    logger.divider();
+    console.log();
+  }
+  logger.hint([chalk3.bold("Command Reference")]);
+  console.log();
+  logger.divider();
+  console.log();
+  console.log(`  ${chalk3.dim("\u2502")}`);
+  COMMANDS.forEach(
+    (cmd, i) => void printCommand(cmd, i === COMMANDS.length - 1)
+  );
+  console.log();
+});
+
+// src/cli/commands/init.ts
+import path5 from "path";
+import { input as input2, select as select2 } from "@inquirer/prompts";
+import chalk4 from "chalk";
+import { Command as Command3 } from "commander";
+import fs4 from "fs-extra";
+
+// src/cli/core/copier.ts
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs3 from "fs-extra";
+var { __PKG_VERSION__: __PKG_VERSION__3 } = resolvePackageManager();
+var Copier = class {
+  static async copyKernel(targetPath) {
+    const __dirname = path4.dirname(fileURLToPath2(import.meta.url));
+    const source = path4.resolve(__dirname, "..", "..", "kernel");
+    const sourceExists = await fs3.pathExists(source);
+    if (!sourceExists) {
+      throw new Error(
+        `Kernel source not found at: ${source}
+Make sure build step copied kernel into dist.`
+      );
+    }
+    const targetExists = await fs3.pathExists(targetPath);
+    if (targetExists) {
+      throw new Error(
+        `Target already exists: ${targetPath}
+Run sync instead or remove it first.`
+      );
+    }
+    await fs3.copy(source, targetPath);
+    const version = typeof __PKG_VERSION__3 !== "undefined" ? __PKG_VERSION__3 : "?";
+    await fs3.writeFile(path4.join(targetPath, ".version"), version, "utf-8");
+  }
+};
+
+// src/cli/commands/init.ts
+var DEFAULTS = {
+  corePath: "src/lib/drimion",
+  importAlias: "drimion",
+  naming: "kebab-case"
+};
+function isCancelled(err) {
+  return err instanceof Error && err.message.includes("force closed the prompt");
+}
+async function askInitQuestions() {
+  const corePath = await input2({
+    message: "Where should the library kernel be installed?",
+    default: DEFAULTS.corePath
+  });
+  const importAlias = await input2({
+    message: "Import alias for your project (configure in tsconfig paths):",
+    default: DEFAULTS.importAlias
+  });
+  const naming = await select2({
+    message: "File naming convention for generated files:",
+    choices: [
+      {
+        value: "kebab-case",
+        name: "kebab-case  (email-address.value-object.ts)"
+      },
+      {
+        value: "snake_case",
+        name: "snake_case  (email_address.value_object.ts)"
+      },
+      {
+        value: "PascalCase",
+        name: "PascalCase  (EmailAddress.ValueObject.ts)"
+      }
+    ]
+  });
+  return { corePath, importAlias, naming };
+}
+function buildConfigTemplate(answers) {
+  return `export default {
+  drimion: {
+    corePath: "${answers.corePath}",
+    importAlias: "${answers.importAlias}",
+    naming: "${answers.naming}",
+    targets: {
+      entity: {},
+      valueObject: {},
+      aggregate: {},
+      repository: {},
+      usecase: {},
+    },
+  },
+};`;
+}
+function step(n) {
+  return chalk4.bgCyan.black(` ${n} `);
+}
+function nextSteps(answers) {
+  return [
+    chalk4.bold("All done! Here's what to do next:"),
+    "",
+    `${step("1")} Add the import alias to your ${chalk4.cyan("tsconfig.json")}:`,
+    "",
+    chalk4.dim('    "paths": {'),
+    chalk4.dim(`      "${answers.importAlias}": ["./${answers.corePath}"]`),
+    chalk4.dim("    }"),
+    "",
+    `${step("2")} Run your first generator:`,
+    "",
+    `    ${chalk4.cyan("npx drimion generate")}`,
+    "",
+    `${step("3")} List available generators:`,
+    "",
+    `    ${chalk4.cyan("npx drimion list")}`,
+    ""
+  ];
+}
+var initCommand = new Command3("init").description("Initialize drimion in your project").option("-y, --yes", "Skip prompts and use defaults").action(async (options) => {
+  logger.banner();
+  try {
+    const cwd = process.cwd();
+    const skipPrompts = options.yes ?? false;
+    let answers;
+    if (skipPrompts) {
+      answers = DEFAULTS;
+      logger.info("Using defaults (--yes).");
+      console.log();
+    } else {
+      try {
+        answers = await askInitQuestions();
+        console.log();
+      } catch (err) {
+        if (isCancelled(err)) {
+          console.log();
+          logger.cancelled();
+          console.log();
+          process.exit(0);
+        }
+        throw err;
+      }
+    }
+    const configPath = path5.resolve(cwd, "drimion.config.ts");
+    const kernelPath = path5.resolve(cwd, answers.corePath);
+    const configExists = await fs4.pathExists(configPath);
+    const kernelExists = await fs4.pathExists(kernelPath);
+    if (configExists && kernelExists) {
+      logger.warn("Already initialized.");
+      console.log();
+      logger.hint([
+        chalk4.bold("Files already in place:"),
+        "",
+        `  ${chalk4.dim("kernel \u2192")} ${answers.corePath}`,
+        `  ${chalk4.dim("config \u2192")} drimion.config.ts`,
+        "",
+        chalk4.dim("Nothing was changed. To reinstall, remove them first."),
+        "",
+        ...nextSteps(answers)
+      ]);
+      process.exit(0);
+    }
+    if (kernelExists) {
+      logger.warn("Kernel already exists \u2014 skipping copy.");
+    } else {
+      const spinner = logger.spinner("Installing library kernel...");
+      await Copier.copyKernel(kernelPath);
+      spinner.succeed(
+        `Kernel installed  ${chalk4.dim("\u2192")} ${answers.corePath}`
+      );
+    }
+    if (configExists) {
+      logger.warn("drimion.config.ts already exists \u2014 skipping.");
+    } else {
+      await fs4.writeFile(configPath, buildConfigTemplate(answers), "utf-8");
+      logger.success(`Config created    ${chalk4.dim("\u2192")} drimion.config.ts`);
+    }
+    console.log();
+    logger.divider();
+    console.log();
+    logger.hint(nextSteps(answers));
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/list.ts
+import chalk5 from "chalk";
+import { Command as Command4 } from "commander";
+var GENERATORS = [
+  "entity",
+  "value-object",
+  "aggregate",
+  "repository",
+  "use-case"
+];
+var COL = 20;
+function lpad(s) {
+  return s.padEnd(COL);
+}
+var listCommand = new Command4("list").description("List available generators and configured targets").action(async () => {
+  logger.banner();
+  try {
+    const config = await Resolver.loadConfig();
+    console.log(`  ${chalk5.bold(lpad("Generator")) + chalk5.bold("Targets")}`);
+    console.log();
+    logger.divider();
+    console.log();
+    for (const type of GENERATORS) {
+      const configKey = toConfigKey(type);
+      const targets = config.drimion.targets?.[configKey] || {};
+      const entries = Object.entries(targets);
+      if (entries.length === 0) {
+        console.log(
+          "  " + chalk5.cyan(lpad(`\u2022 ${type}`)) + chalk5.dim("(no targets configured)")
+        );
+        continue;
+      }
+      entries.forEach(([name, targetPath], i) => {
+        const leftStyled = i === 0 ? chalk5.cyan(`\u2022 ${type}`) + " ".repeat(Math.max(0, COL - `\u2022 ${type}`.length)) : " ".repeat(COL);
+        const idx = chalk5.dim(`(${i + 1})`);
+        const targetName = chalk5.white(name);
+        const tPath = chalk5.dim(targetPath);
+        console.log(`  ${leftStyled}${idx} ${targetName}: ${tPath}`);
+      });
+    }
+    console.log();
+    logger.divider();
+    console.log();
+    logger.hint([
+      `Run ${chalk5.cyan("npx drimion generate")} to create a new file.`
+    ]);
+    console.log();
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/sync.ts
+import path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { select as select3 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+import { Command as Command5 } from "commander";
+import fs5 from "fs-extra";
+var { __PKG_VERSION__: __PKG_VERSION__4 } = resolvePackageManager();
+function isCancelled2(err) {
+  return err instanceof Error && err.message.includes("force closed the prompt");
+}
+function resolveKernelSource() {
+  const __dirname = path6.dirname(fileURLToPath3(import.meta.url));
+  return path6.resolve(__dirname, "..", "..", "kernel");
+}
+async function readInstalledVersion(kernelPath) {
+  const versionFile = path6.join(kernelPath, ".version");
+  try {
+    const raw = await fs5.readFile(versionFile, "utf-8");
+    return raw.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getPackageVersion() {
+  return typeof __PKG_VERSION__4 !== "undefined" ? __PKG_VERSION__4 : "?";
+}
+var syncCommand = new Command5("sync").description("Update the library kernel to the latest version").option("-f, --force", "Overwrite everything \u2014 no prompts, no backup").action(async (options) => {
+  logger.banner();
+  const cwd = process.cwd();
+  const force = options.force ?? false;
+  try {
+    const config = await Resolver.loadConfig(cwd);
+    const kernelPath = Resolver.resolveCorePath(config, cwd);
+    const kernelSource = resolveKernelSource();
+    const sourceExists = await fs5.pathExists(kernelSource);
+    if (!sourceExists) {
+      logger.error(
+        `Kernel source not found at: ${kernelSource}
+Make sure the package is up to date.`
+      );
+      console.log();
+      process.exit(1);
+    }
+    const kernelExists = await fs5.pathExists(kernelPath);
+    if (!kernelExists) {
+      logger.warn("Kernel not found \u2014 nothing to sync.");
+      console.log();
+      logger.hint([
+        chalk6.dim(`Expected at: ${path6.relative(cwd, kernelPath)}`),
+        chalk6.dim("Run `npx drimion init` to install first.")
+      ]);
+      console.log();
+      process.exit(0);
+    }
+    const installedVersion = await readInstalledVersion(kernelPath);
+    const availableVersion = getPackageVersion();
+    const relativeKernelPath = path6.relative(cwd, kernelPath);
+    if (installedVersion && installedVersion === availableVersion && !force) {
+      logger.hint([
+        `${chalk6.green("\u2714")} Kernel is already up to date.`,
+        "",
+        `  ${chalk6.dim("version")}    ${chalk6.cyan(installedVersion)}`,
+        `  ${chalk6.dim("path")}       ${chalk6.white(relativeKernelPath)}`
+      ]);
+      console.log();
+      process.exit(0);
+    }
+    if (installedVersion || availableVersion) {
+      logger.hint([
+        chalk6.bold("A new version of the library kernel is available."),
+        "",
+        `  ${chalk6.dim("installed")}   ${chalk6.yellow(installedVersion ?? "unknown")}`,
+        `  ${chalk6.dim("available")}   ${chalk6.cyan(availableVersion)}`
+      ]);
+      console.log();
+    }
+    if (force) {
+      const spinner2 = logger.spinner("Syncing kernel...");
+      await fs5.remove(kernelPath);
+      await fs5.copy(kernelSource, kernelPath);
+      spinner2.succeed(
+        `Kernel updated  ${chalk6.dim("\u2192")} ${relativeKernelPath}`
+      );
+      console.log();
+      process.exit(0);
+    }
+    let choice;
+    try {
+      choice = await select3({
+        message: "What do you want to do?",
+        choices: [
+          { value: "overwrite", name: "Overwrite existing files" },
+          { value: "skip", name: "Skip update" },
+          {
+            value: "backup",
+            name: "Backup current version and install new"
+          }
+        ]
+      });
+      console.log();
+    } catch (err) {
+      if (isCancelled2(err)) {
+        console.log();
+        logger.cancelled();
+        console.log();
+        process.exit(0);
+      }
+      throw err;
+    }
+    if (choice === "skip") {
+      logger.cancelled();
+      console.log();
+      process.exit(0);
+    }
+    if (choice === "backup") {
+      const backupVersion = installedVersion ?? "unknown";
+      const backupPath = path6.join(
+        kernelPath,
+        "__backup__",
+        `v${backupVersion}`
+      );
+      const tempBackupPath = path6.join(cwd, `.drimion-backup-${Date.now()}`);
+      const relativeBackupPath = path6.relative(cwd, backupPath);
+      const spinner2 = logger.spinner("Backing up current kernel...");
+      await fs5.copy(kernelPath, tempBackupPath);
+      spinner2.succeed(
+        `Backup saved    ${chalk6.dim("\u2192")} ${relativeBackupPath}`
+      );
+      const spinner22 = logger.spinner("Installing new kernel...");
+      await fs5.remove(kernelPath);
+      await Copier.copyKernel(kernelPath);
+      await fs5.move(tempBackupPath, backupPath);
+      spinner22.succeed(
+        `Kernel updated  ${chalk6.dim("\u2192")} ${relativeKernelPath}`
+      );
+      console.log();
+      logger.divider();
+      console.log();
+      logger.hint([
+        chalk6.bold("Sync complete."),
+        "",
+        `  ${chalk6.dim("backup")}   ${chalk6.white(relativeBackupPath)}`,
+        "",
+        chalk6.dim("Remember to add the backup directory to .gitignore:"),
+        "",
+        `  ${chalk6.dim(`${relativeKernelPath}/__backup__/`)}`
+      ]);
+      console.log();
+      process.exit(0);
+    }
+    const spinner = logger.spinner("Syncing kernel...");
+    await fs5.remove(kernelPath);
+    await Copier.copyKernel(kernelPath);
+    spinner.succeed(
+      `Kernel updated  ${chalk6.dim("\u2192")} ${relativeKernelPath}`
+    );
+    console.log();
+    logger.divider();
+    console.log();
+    logger.hint([chalk6.bold("Sync complete.")]);
+    console.log();
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/uninstall.ts
+import path7 from "path";
+import { confirm } from "@inquirer/prompts";
+import chalk7 from "chalk";
+import { Command as Command6 } from "commander";
+import fs6 from "fs-extra";
+function isCancelled3(err) {
+  return err instanceof Error && err.message.includes("force closed the prompt");
+}
+var uninstallCommand = new Command6("uninstall").description("Remove drimion kernel and config from your project").action(async () => {
+  logger.banner();
+  const cwd = process.cwd();
+  const configPath = path7.resolve(cwd, "drimion.config.ts");
+  const configExists = await fs6.pathExists(configPath);
+  let kernelPath;
+  try {
+    const config = await Resolver.loadConfig(cwd);
+    kernelPath = path7.resolve(cwd, config.drimion.corePath);
+  } catch {
+    kernelPath = path7.resolve(cwd, "src/lib/drimion");
+  }
+  const kernelExists = await fs6.pathExists(kernelPath);
+  if (!configExists && !kernelExists) {
+    logger.warn("Nothing to uninstall \u2014 no config or kernel found.");
+    console.log();
+    process.exit(0);
+  }
+  logger.hint([
+    chalk7.bold("The following will be permanently deleted:"),
+    "",
+    ...kernelExists ? [`  ${chalk7.red("\u2716")} ${path7.relative(cwd, kernelPath)}`] : [],
+    ...configExists ? [`  ${chalk7.red("\u2716")} drimion.config.ts`] : []
+  ]);
+  let confirmed;
+  try {
+    console.log();
+    confirmed = await confirm({
+      message: "Are you sure? This cannot be undone.",
+      default: false
+    });
+    console.log();
+  } catch (err) {
+    if (isCancelled3(err)) {
+      console.log();
+      logger.cancelled();
+      console.log();
+      process.exit(0);
+    }
+    throw err;
+  }
+  if (!confirmed) {
+    console.log();
+    logger.cancelled();
+    console.log();
+    process.exit(0);
+  }
+  if (kernelExists) {
+    await fs6.remove(kernelPath);
+    logger.success(
+      `Removed  ${chalk7.dim("\u2192")} ${path7.relative(cwd, kernelPath)}`
+    );
+  }
+  if (configExists) {
+    await fs6.remove(configPath);
+    logger.success(`Removed  ${chalk7.dim("\u2192")} drimion.config.ts`);
+  }
+  console.log();
+  logger.divider();
+  console.log();
+  logger.hint([chalk7.dim("Uninstall complete. Run init to start fresh.")]);
+  console.log();
+});
+
+// src/cli/index.ts
+var program = new Command7();
+var { __PKG_NAME__: __PKG_NAME__3, __PKG_VERSION__: __PKG_VERSION__5 } = resolvePackageManager();
+program.name(__PKG_NAME__3).description("Headless DDD Toolkit CLI").version(__PKG_VERSION__5);
+program.addCommand(infoCommand);
+program.addCommand(initCommand);
+program.addCommand(listCommand);
+program.addCommand(generateCommand);
+program.addCommand(syncCommand);
+program.addCommand(uninstallCommand);
+program.parse();