@codejen/jen 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/core.d.ts

@@ -0,0 +1,72 @@
+export type Answers = Record<string, any>;
+/** A parameter's default also decides its type: boolean default → boolean, otherwise string. */
+export type Params = Record<string, {
+    default?: string | boolean;
+}>;
+export type Action = 
+/** Create a file. Skipped if it exists (unless force / --force). */
+{
+    add: string;
+    template: string;
+    force?: boolean;
+}
+/**
+ * Insert `line` before the marker line. A single line reuses the marker's
+ * own indentation exactly; a `\n`-joined block is re-rendered in the
+ * file's indent style, keeping the block's relative nesting. No duplicates.
+ */
+ | {
+    insert: string;
+    before: string;
+    line: string;
+}
+/**
+ * Search and replace via RegExp. Also handy for removing lines. A
+ * multi-line `replace` is reindented to match the first match's line.
+ */
+ | {
+    modify: string;
+    pattern: RegExp;
+    replace: string;
+}
+/** Delete a file. Only inside the project root; directories are refused. */
+ | {
+    delete: string;
+};
+export interface Helpers {
+    pascal(s: string): string;
+    camel(s: string): string;
+    snake(s: string): string;
+    kebab(s: string): string;
+    constant(s: string): string;
+}
+export interface Generator {
+    description?: string;
+    params?: Params;
+    actions(answers: Answers, helpers: Helpers): Action[];
+}
+/** Default export of a jen pack: generator name → generator. */
+export type Pack = Record<string, Generator>;
+export declare const helpers: Helpers;
+export declare function fail(message: string): never;
+export declare const dim: (s: string) => string;
+export interface Step {
+    mark: '+' | '~' | '!' | '-' | '=' | '?';
+    file: string;
+    note?: string;
+}
+/**
+ * Computes all changes in memory without touching the disk.
+ * `changes` holds the final state of every affected file (null = delete),
+ * so several actions on the same file (e.g. add, then insert) build on each other.
+ */
+export declare function plan(actions: Action[], force: boolean): Promise<{
+    steps: Step[];
+    changes: Map<string, string | null>;
+}>;
+/** Writes or deletes everything the plan computed. */
+export declare function apply(changes: Map<string, string | null>): Promise<{
+    written: number;
+    deleted: number;
+}>;
+export declare function printPlan(steps: Step[]): void;

package/dist/editorconfig.d.ts

@@ -0,0 +1,31 @@
+/** Walks upward from the file, merging matching .editorconfig sections (closer file & later section win). */
+export declare function editorConfigFor(file: string): Record<string, string>;
+/** Normalizes indentation, line endings, trailing whitespace and final newline per editorconfig props. */
+export declare function applyEditorConfig(content: string, props: Record<string, string>): string;
+/** What newly introduced lines in `text` should be indented with: .editorconfig wins, else the file's own style. */
+export declare function indentTargetFor(file: string, text: string): {
+    style: 'tab' | 'space';
+    size: number;
+};
+/**
+ * Re-renders a block of lines in the target indent style, preserving their
+ * relative nesting (the block's own smallest indent becomes one level).
+ * `baseIndent` is prefixed to every line, e.g. the marker's own indentation.
+ * A single line is just trimmed and prefixed – exactly today's behaviour.
+ */
+export declare function reindentBlock(block: string[], baseIndent: string, target: {
+    style: 'tab' | 'space';
+    size: number;
+}): string[];
+/** Whether `block` (compared line-by-line, trimmed) already occurs anywhere in `lines`. */
+export declare function containsBlock(lines: string[], block: string[]): boolean;
+/**
+ * Reindents a multi-line `replace` template to match the indentation at its
+ * first match in `text`. The first line continues inline right after the
+ * match, so it's left exactly as written; only the following lines – which
+ * start fresh – are re-rendered in the file's indent style.
+ */
+export declare function reindentReplace(text: string, pattern: RegExp, replace: string, target: {
+    style: 'tab' | 'space';
+    size: number;
+}): string;

package/dist/jen.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export type { Action, Answers, Generator, Helpers, Pack, Params } from './core.ts';
+export { helpers } from './core.ts';

package/dist/jen.js

@@ -0,0 +1,705 @@
+#!/usr/bin/env node
+
+// src/jen.ts
+import { realpathSync } from "node:fs";
+import { styleText as styleText3 } from "node:util";
+
+// src/cli.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync4, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { tmpdir } from "node:os";
+import { delimiter, join as join3, resolve as resolve2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { parseArgs, styleText as styleText2 } from "node:util";
+
+// src/core.ts
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute, relative as relative2, resolve } from "node:path";
+import { styleText } from "node:util";
+
+// src/editorconfig.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+function parseEditorConfig(text) {
+  let root = false;
+  const sections = [];
+  let current = null;
+  for (const rawLine of text.split(/\r\n|\r|\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+    const section = line.match(/^\[(.+)\]$/);
+    if (section) {
+      current = { pattern: section[1], props: {} };
+      sections.push(current);
+      continue;
+    }
+    const kv = line.match(/^([^=]+)=(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim().toLowerCase();
+    const value = kv[2].trim();
+    if (current) current.props[key] = value.toLowerCase();
+    else if (key === "root") root = value.toLowerCase() === "true";
+  }
+  return { root, sections };
+}
+var RE_SPECIAL = /[.+^$()|\\\]]/g;
+function globToRegExp(glob) {
+  const pattern = glob.includes("/") ? glob.replace(/^\//, "") : `**/${glob}`;
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i++;
+      if (pattern[i + 1] === "/") i++;
+    } else if (c === "*") {
+      re += "[^/]*";
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "[") {
+      const end = pattern.indexOf("]", i + 1);
+      if (end < 0) {
+        re += "\\[";
+      } else {
+        const cls = pattern.slice(i + 1, end);
+        re += `[${cls.startsWith("!") ? `^${cls.slice(1)}` : cls}]`;
+        i = end;
+      }
+    } else if (c === "{") {
+      const end = pattern.indexOf("}", i + 1);
+      if (end < 0) {
+        re += "\\{";
+      } else {
+        const alts = pattern.slice(i + 1, end).split(",").map((s) => s.replace(RE_SPECIAL, "\\$&"));
+        re += `(?:${alts.join("|")})`;
+        i = end;
+      }
+    } else {
+      re += c.replace(RE_SPECIAL, "\\$&");
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function editorConfigFor(file) {
+  const chain = [];
+  let dir = dirname(file);
+  for (; ; ) {
+    const cfgPath = join(dir, ".editorconfig");
+    if (existsSync(cfgPath)) {
+      const { root, sections } = parseEditorConfig(readFileSync(cfgPath, "utf8"));
+      const rel = relative(dir, file);
+      const matched = sections.filter((s) => globToRegExp(s.pattern).test(rel)).map((s) => s.props);
+      if (matched.length > 0) chain.push(matched);
+      if (root) break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const props = {};
+  for (const fileMatches of chain.reverse()) for (const p of fileMatches) Object.assign(props, p);
+  return props;
+}
+function applyEditorConfig(content, props) {
+  if (Object.keys(props).length === 0) return content;
+  const eol = props.end_of_line === "crlf" ? "\r\n" : props.end_of_line === "cr" ? "\r" : "\n";
+  const hadFinalNewline = /\r\n$|\r$|\n$/.test(content);
+  const lines = content.split(/\r\n|\r|\n/);
+  if (hadFinalNewline) lines.pop();
+  const indentSize = Number(props.indent_size === "tab" ? props.tab_width : props.indent_size) || void 0;
+  const formatted = lines.map((line) => {
+    let out = line;
+    if (indentSize && (props.indent_style === "space" || props.indent_style === "tab")) {
+      const indent = out.match(/^[ \t]*/)?.[0] ?? "";
+      let columns = 0;
+      for (const ch of indent) columns += ch === "	" ? indentSize : 1;
+      const newIndent = props.indent_style === "tab" ? "	".repeat(Math.floor(columns / indentSize)) + " ".repeat(columns % indentSize) : " ".repeat(columns);
+      out = newIndent + out.slice(indent.length);
+    }
+    return props.trim_trailing_whitespace === "true" ? out.replace(/[ \t]+$/, "") : out;
+  });
+  let result = formatted.join(eol);
+  if (props.insert_final_newline === "true" || hadFinalNewline && props.insert_final_newline !== "false") {
+    result += eol;
+  }
+  return result;
+}
+function sniffIndent(text) {
+  const leads = text.split("\n").map((l) => l.match(/^[ \t]+/)?.[0] ?? "").filter(Boolean);
+  const tabs = leads.filter((l) => l[0] === "	").length;
+  const spaced = leads.filter((l) => l[0] === " ").map((l) => l.length);
+  if (tabs > 0 && tabs >= spaced.length) return { style: "tab", size: 1 };
+  if (spaced.length === 0) return { style: "space", size: 2 };
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  return { style: "space", size: spaced.reduce(gcd) };
+}
+function indentTargetFor(file, text) {
+  const props = editorConfigFor(file);
+  const style = props.indent_style === "tab" || props.indent_style === "space" ? props.indent_style : void 0;
+  const size = Number(props.indent_size === "tab" ? props.tab_width : props.indent_size) || void 0;
+  const sniffed = sniffIndent(text);
+  return { style: style ?? sniffed.style, size: size ?? sniffed.size };
+}
+function reindentBlock(block, baseIndent, target) {
+  if (block.length <= 1) return [baseIndent + (block[0] ?? "").trim()];
+  const leads = block.filter((l) => l.trim() !== "").map((l) => l.match(/^[ \t]*/)?.[0].length ?? 0);
+  const unit = Math.min(...leads.filter((n) => n > 0), Infinity);
+  const step = target.style === "tab" ? "	" : " ".repeat(target.size);
+  return block.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return "";
+    const lead = line.match(/^[ \t]*/)?.[0].length ?? 0;
+    const level = unit > 0 && Number.isFinite(unit) ? Math.round(lead / unit) : 0;
+    return baseIndent + step.repeat(level) + trimmed;
+  });
+}
+function containsBlock(lines, block) {
+  const b = block.map((l) => l.trim());
+  for (let k = 0; k + b.length <= lines.length; k++) {
+    if (b.every((l, j) => lines[k + j].trim() === l)) return true;
+  }
+  return false;
+}
+function reindentReplace(text, pattern, replace, target) {
+  const search = new RegExp(pattern.source, pattern.flags.replace("g", ""));
+  const m = search.exec(text);
+  if (!m) return replace;
+  const lineStart = text.lastIndexOf("\n", m.index - 1) + 1;
+  const baseIndent = text.slice(lineStart, m.index).match(/^[ \t]*/)?.[0] ?? "";
+  const lines = replace.split("\n");
+  const rendered = reindentBlock(lines, baseIndent, target);
+  return [lines[0], ...rendered.slice(1)].join("\n");
+}
+
+// src/location.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+function findUp(name, dir = process.cwd()) {
+  for (; ; ) {
+    const candidate = join2(dir, name);
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var PROJECT_JEN = findUp(".jen");
+var ROOT = PROJECT_JEN ? dirname2(PROJECT_JEN) : process.cwd();
+function setRoot(root) {
+  ROOT = root;
+}
+var USER_DIR = process.env.XDG_CONFIG_HOME ? join2(process.env.XDG_CONFIG_HOME, "jen") : process.platform === "win32" ? join2(process.env.APPDATA ?? homedir(), "jen") : join2(homedir(), ".config", "jen");
+
+// src/core.ts
+var words = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_\-./]+/).filter(Boolean);
+var cap = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+var helpers = {
+  pascal: (s) => words(s).map(cap).join(""),
+  camel: (s) => {
+    const p = helpers.pascal(s);
+    return p.charAt(0).toLowerCase() + p.slice(1);
+  },
+  snake: (s) => words(s).map((w) => w.toLowerCase()).join("_"),
+  kebab: (s) => words(s).map((w) => w.toLowerCase()).join("-"),
+  constant: (s) => words(s).map((w) => w.toUpperCase()).join("_")
+};
+function fail(message) {
+  throw new Error(message);
+}
+var dim = (s) => styleText("dim", s);
+var isFile = (f) => existsSync3(f) && statSync(f).isFile();
+var isInside = (root, f) => {
+  const rel = relative2(root, f);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+};
+async function plan(actions, force) {
+  const steps = [];
+  const changes = /* @__PURE__ */ new Map();
+  const added = /* @__PURE__ */ new Set();
+  const read = async (f) => changes.has(f) ? changes.get(f) ?? null : isFile(f) ? await readFile(f, "utf8") : null;
+  for (const a of actions) {
+    if ("add" in a) {
+      const file2 = resolve(ROOT, a.add);
+      const exists = await read(file2) !== null;
+      if (exists && !(a.force || force)) {
+        steps.push({ mark: "=", file: file2, note: "exists, skipped" });
+        continue;
+      }
+      changes.set(file2, a.template);
+      added.add(file2);
+      steps.push(exists ? { mark: "!", file: file2, note: "will be overwritten" } : { mark: "+", file: file2 });
+      continue;
+    }
+    if ("delete" in a) {
+      const file2 = resolve(ROOT, a.delete);
+      if (!isInside(ROOT, file2)) {
+        steps.push({ mark: "?", file: file2, note: "outside the project, skipped" });
+      } else if (existsSync3(file2) && !changes.has(file2) && !isFile(file2)) {
+        steps.push({ mark: "?", file: file2, note: "is a directory, skipped" });
+      } else if (await read(file2) === null) {
+        steps.push({ mark: "=", file: file2, note: "does not exist" });
+      } else {
+        changes.set(file2, null);
+        steps.push({ mark: "-", file: file2 });
+      }
+      continue;
+    }
+    const file = resolve(ROOT, "insert" in a ? a.insert : a.modify);
+    const text = await read(file);
+    if (text === null) {
+      steps.push({ mark: "?", file, note: "file missing, skipped" });
+      continue;
+    }
+    if ("insert" in a) {
+      const lines = text.split("\n");
+      const block = a.line.split("\n");
+      if (containsBlock(lines, block)) {
+        steps.push({ mark: "=", file, note: `already present: ${block[0].trim()}${block.length > 1 ? " \u2026" : ""}` });
+        continue;
+      }
+      const i = lines.findIndex((l) => l.includes(a.before));
+      if (i < 0) {
+        steps.push({ mark: "?", file, note: `marker "${a.before}" not found` });
+        continue;
+      }
+      const baseIndent = lines[i].match(/^\s*/)?.[0] ?? "";
+      const rendered = reindentBlock(block, baseIndent, indentTargetFor(file, text));
+      lines.splice(i, 0, ...rendered);
+      changes.set(file, lines.join("\n"));
+      steps.push({
+        mark: "~",
+        file,
+        note: `+ ${block[0].trim()}${block.length > 1 ? ` (+${block.length - 1} more)` : ""}`
+      });
+    } else {
+      const replace = a.replace.includes("\n") ? reindentReplace(text, a.pattern, a.replace, indentTargetFor(file, text)) : a.replace;
+      const next = text.replace(a.pattern, replace);
+      if (next === text) {
+        steps.push({ mark: "=", file, note: `no match for ${a.pattern}` });
+        continue;
+      }
+      changes.set(file, next);
+      steps.push({ mark: "~", file, note: `${a.pattern} replaced` });
+    }
+  }
+  for (const file of added) {
+    const content = changes.get(file);
+    if (typeof content === "string") changes.set(file, applyEditorConfig(content, editorConfigFor(file)));
+  }
+  return { steps, changes };
+}
+async function apply(changes) {
+  let written = 0;
+  let deleted = 0;
+  for (const [file, content] of changes) {
+    if (content === null) {
+      if (isFile(file)) {
+        await rm(file);
+        deleted++;
+      }
+      continue;
+    }
+    await mkdir(dirname3(file), { recursive: true });
+    await writeFile(file, content);
+    written++;
+  }
+  return { written, deleted };
+}
+var MARK_STYLE = {
+  "+": "green",
+  "~": "cyan",
+  "!": "yellow",
+  "-": "red",
+  "=": "dim",
+  "?": "magenta"
+};
+function printPlan(steps) {
+  for (const s of steps) {
+    const note = s.note ? dim(`  ${s.note}`) : "";
+    console.log(`  ${styleText(MARK_STYLE[s.mark], s.mark)} ${relative2(process.cwd(), s.file)}${note}`);
+  }
+}
+
+// src/yeoman.ts
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+var PRIORITIES = ["initializing", "prompting", "configuring", "default", "writing", "transform", "conflicts"];
+function answerPrompt(questions, given) {
+  const list2 = Array.isArray(questions) ? questions : [questions];
+  const answers = {};
+  const missing = [];
+  for (const q of list2) {
+    if (q.name in given) {
+      answers[q.name] = given[q.name];
+    } else if (typeof q.default === "function") {
+      answers[q.name] = q.default(answers);
+    } else if (q.default !== void 0) {
+      answers[q.name] = q.default;
+    } else {
+      missing.push(q.name);
+    }
+  }
+  if (missing.length > 0) {
+    fail(`Missing: ${missing.map((n) => `--${n}`).join(", ")} (asked by the generator's prompting step; jen never prompts).`);
+  }
+  return answers;
+}
+function makeLog() {
+  const log = ((...args) => {
+    console.log(...args);
+    return log;
+  });
+  for (const level of ["error", "warn", "info", "ok"]) {
+    log[level] = (...args) => {
+      console.log(...args);
+      return log;
+    };
+  }
+  return log;
+}
+function toArgv(given, positionals) {
+  const flags = Object.entries(given).flatMap(
+    ([name, value]) => typeof value === "boolean" ? value ? [`--${name}`] : [] : [`--${name}=${String(value)}`]
+  );
+  return [...flags, ...positionals];
+}
+async function runYeoman(GeneratorClass, resolved, ctx) {
+  const require2 = createRequire(resolved);
+  const memFs = await import(pathToFileURL(require2.resolve("mem-fs")).href);
+  const sharedFs = memFs.create();
+  const queues = new Map(PRIORITIES.map((name) => [name, []]));
+  const env = {
+    cwd: ctx.root,
+    logCwd: ctx.root,
+    sharedFs,
+    options: {},
+    adapter: {
+      log: makeLog(),
+      prompt: async (questions) => answerPrompt(questions, ctx.given),
+      // eslint-disable-next-line @typescript-eslint/no-empty-function -- only used for progress messages we don't print
+      progress: async (fn) => fn({ step() {
+      } })
+    },
+    getVersion: () => "999.0.0",
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- custom priorities aren't supported, nothing to register
+    addPriority() {
+    },
+    queueTask(queueName, fn) {
+      queues.get(queueName)?.push(fn);
+    },
+    composeWith() {
+      fail("This generator uses composeWith (sub-generator composition), which jen's Yeoman support doesn't cover.");
+    },
+    async runGenerator(generator2) {
+      await generator2.queueTasks();
+      for (const name of PRIORITIES) {
+        for (const task of queues.get(name) ?? []) await task();
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- nothing listens on the env, so events are dropped
+    emit() {
+    }
+  };
+  const generator = new GeneratorClass(toArgv(ctx.given, ctx.positionals), {
+    env,
+    resolved,
+    namespace: ctx.namespace,
+    skipCache: true,
+    skipLocalCache: true,
+    skipInstall: true
+  });
+  await generator.run();
+  const actions = [];
+  for (const file of sharedFs.all()) {
+    if (file.state === "modified") actions.push({ add: file.path, template: (file.contents ?? Buffer.alloc(0)).toString("utf8") });
+    else if (file.state === "deleted") actions.push({ delete: file.path });
+  }
+  return actions;
+}
+
+// src/cli.ts
+var BUILTINS = {
+  generator: {
+    description: "create a new generator (project or user-wide)",
+    params: {
+      name: {},
+      location: { default: "project" }
+    },
+    actions: ({ name, location }, { kebab }) => [
+      {
+        add: join3(location === "user" ? USER_DIR : join3(ROOT, ".jen"), `${kebab(name)}.mjs`),
+        template: `// @ts-check
+/** @type {import('@codejen/jen').Generator} */
+export default {
+  description: ${JSON.stringify(String(name))},
+  params: {
+    name: {},
+  },
+  actions: ({ name }, { pascal }) => [
+    { add: \`src/\${pascal(name)}.txt\`, template: \`Hello \${name}!\\n\` },
+  ],
+};
+`
+      }
+    ]
+  }
+};
+var GEN_FILE = /\.(m?js|m?ts)$/;
+function asGenerator(mod, where) {
+  const m = mod;
+  const gen = m.default ?? m;
+  if (typeof gen?.actions !== "function") fail(`${where}: does not export an actions() function`);
+  return { kind: "actions", ...gen };
+}
+function dirSource(source, dir) {
+  if (!dir || !existsSync4(dir)) return [];
+  return readdirSync(dir).filter((f) => GEN_FILE.test(f) && !f.endsWith(".d.ts")).map((f) => {
+    const file = join3(dir, f);
+    return {
+      name: f.replace(GEN_FILE, ""),
+      source,
+      load: async () => asGenerator(await import(pathToFileURL2(file).href), file)
+    };
+  });
+}
+var PACK_RE = /^(?:jen-pack-|@[^/]+\/pack-)(.+)$/;
+var packPrefix = (name) => PACK_RE.exec(name)?.[1] ?? name;
+function readPackageJson(dir) {
+  const file = dir ? join3(dir, "package.json") : null;
+  if (!file || !existsSync4(file)) return {};
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch (e) {
+    fail(`${file}: ${e.message}`);
+  }
+}
+function discoverDeps(dir, re) {
+  const pkg = readPackageJson(dir);
+  const names = [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {})
+  ];
+  return names.filter((n) => re.test(n));
+}
+async function packSource(name, bases = [join3(ROOT, "package.json"), import.meta.filename]) {
+  for (const base of bases) {
+    let file;
+    try {
+      file = createRequire2(base).resolve(name);
+    } catch {
+      continue;
+    }
+    const mod = await import(pathToFileURL2(file).href);
+    const pack = mod.default ?? mod;
+    return Object.entries(pack).map(([gen, g]) => ({
+      name: gen,
+      source: `pack ${name}`,
+      prefix: packPrefix(name),
+      load: async () => asGenerator(g, `${name}:${gen}`)
+    }));
+  }
+  console.warn(styleText2("yellow", `Pack ${name} not found (install it locally or globally).`));
+  return [];
+}
+var YEOMAN_RE = /^(?:generator-|@[^/]+\/generator-)(.+)$/;
+var yeomanShortName = (name) => YEOMAN_RE.exec(name)?.[1] ?? name;
+async function yeomanSource(name, bases = [join3(ROOT, "package.json"), import.meta.filename]) {
+  for (const base of bases) {
+    let file;
+    try {
+      file = createRequire2(base).resolve(name);
+    } catch {
+      continue;
+    }
+    const mod = await import(pathToFileURL2(file).href);
+    const GeneratorClass = mod.default ?? mod;
+    if (typeof GeneratorClass !== "function") {
+      console.warn(styleText2("yellow", `${name}: default export is not a Yeoman generator class, skipped.`));
+      return [];
+    }
+    const shortName = yeomanShortName(name);
+    return [
+      {
+        name: shortName,
+        source: `yeoman ${name}`,
+        load: async () => ({
+          kind: "yeoman",
+          description: "Yeoman generator",
+          run: (given, positionals) => runYeoman(GeneratorClass, file, { given, positionals, root: ROOT, namespace: `${shortName}:app` })
+        })
+      }
+    ];
+  }
+  console.warn(styleText2("yellow", `Yeoman generator ${name} not found (install it locally or globally).`));
+  return [];
+}
+function splitPkgSpec(spec) {
+  const at = spec.startsWith("@") ? spec.indexOf("@", 1) : spec.indexOf("@");
+  return at < 0 ? [spec, "latest"] : [spec.slice(0, at), spec.slice(at + 1)];
+}
+async function fetchFrom(spec) {
+  const [name, version] = splitPkgSpec(spec);
+  if (!PACK_RE.test(name) && !YEOMAN_RE.test(name)) {
+    fail(`"${name}" doesn't look like a jen pack (jen-pack-*, @scope/pack-*) or a Yeoman generator (generator-*, @scope/generator-*).`);
+  }
+  const dir = mkdtempSync(join3(tmpdir(), "jen-from-"));
+  const remove = () => rmSync(dir, { recursive: true, force: true });
+  const onSignal = (signal) => {
+    remove();
+    process.exit(128 + (signal === "SIGINT" ? 2 : 15));
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  const cleanup = () => {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    remove();
+  };
+  console.log(dim(`Fetching ${name}@${version} \u2026`));
+  const result = spawnSync(
+    "npm",
+    ["install", `${name}@${version}`, "--prefix", dir, "--no-save", "--no-audit", "--no-fund", "--ignore-scripts"],
+    { stdio: "inherit", shell: process.platform === "win32" }
+  );
+  if (result.error || result.status !== 0) {
+    cleanup();
+    fail(`npm install ${name}@${version} failed${result.error ? `: ${result.error.message}` : ""}.`);
+  }
+  const bases = [join3(dir, "package.json")];
+  const entries = PACK_RE.test(name) ? await packSource(name, bases) : await yeomanSource(name, bases);
+  return { entries, cleanup };
+}
+async function collect() {
+  const extra = (process.env.JEN_PATH ?? "").split(delimiter).filter(Boolean);
+  const packs = [.../* @__PURE__ */ new Set([...discoverDeps(ROOT, PACK_RE), ...discoverDeps(USER_DIR, PACK_RE)])];
+  const yeomanGenerators = [.../* @__PURE__ */ new Set([...discoverDeps(ROOT, YEOMAN_RE), ...discoverDeps(USER_DIR, YEOMAN_RE)])];
+  const entries = [
+    ...dirSource("project", PROJECT_JEN),
+    ...dirSource("user", USER_DIR),
+    ...extra.flatMap((dir) => dirSource(`JEN_PATH ${dir}`, dir))
+  ];
+  for (const p of packs) entries.push(...await packSource(p));
+  for (const g of yeomanGenerators) entries.push(...await yeomanSource(g));
+  for (const [name, g] of Object.entries(BUILTINS)) {
+    entries.push({ name, source: "built-in", load: async () => ({ kind: "actions", ...g }) });
+  }
+  return entries;
+}
+var qualified = (e) => e.prefix ? `${e.prefix}:${e.name}` : e.name;
+function find(entries, query) {
+  const colon = query.indexOf(":");
+  const prefix = colon < 0 ? null : query.slice(0, colon);
+  const name = colon < 0 ? query : query.slice(colon + 1);
+  return entries.find(
+    (e) => e.name === name && (prefix === null || e.prefix === prefix || e.source === prefix || e.source.startsWith(`${prefix} `))
+  );
+}
+async function list(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    const shadowed = seen.has(e.name);
+    seen.add(e.name);
+    const description = await e.load().then(
+      (g) => g.description ?? "",
+      (err) => styleText2("red", err.message)
+    );
+    const line = `  ${qualified(e).padEnd(22)} ${e.source.padEnd(26)} ${description}`;
+    console.log(shadowed ? dim(`${line} (shadowed)`) : line);
+  }
+}
+var TRUE = /^(1|true|y|yes)$/i;
+function resolveParams(params, given) {
+  const answers = {};
+  const missing = [];
+  for (const [name, spec] of Object.entries(params)) {
+    if (name in given) {
+      const v = given[name];
+      answers[name] = typeof spec.default === "boolean" ? v === true || TRUE.test(String(v)) : String(v);
+    } else if (spec.default !== void 0) {
+      answers[name] = spec.default;
+    } else {
+      missing.push(name);
+    }
+  }
+  if (missing.length > 0) {
+    const usage = Object.entries(params).map(([name, spec]) => spec.default === void 0 ? `--${name}=\u2026` : `--${name}=${spec.default}`).join(" ");
+    fail(`Missing: ${missing.map((n) => `--${n}`).join(", ")}. Usage: ${usage}`);
+  }
+  return answers;
+}
+var HELP = `jen \u2013 the code jen(erator)
+
+  jen [generator] [--answer=value \u2026] [options]
+
+  generator       name ("class"), with pack ("cpp:class") or source ("user:class")
+  --list,    -l   list all generators and where they come from
+  --dry-run, -n   only show the plan
+  --force,   -f   overwrite existing files
+  --where,   -w   generate into this directory instead of the project root
+  --from          fetch a pack or Yeoman generator via npm, run it once, then remove it
+  --help,    -h   show this help
+
+  CLI answers always use "=": --name=Foo (flags like --moveOnly work without).
+  Without a generator name, jen lists the available ones.
+`;
+var FLAGS = {
+  list: { type: "boolean", short: "l" },
+  "dry-run": { type: "boolean", short: "n" },
+  force: { type: "boolean", short: "f" },
+  where: { type: "string", short: "w" },
+  from: { type: "string" },
+  help: { type: "boolean", short: "h" }
+};
+async function main() {
+  const { values, positionals } = parseArgs({ allowPositionals: true, strict: false, options: FLAGS });
+  if (values.help) return void console.log(HELP);
+  if (values.where) setRoot(resolve2(process.cwd(), String(values.where)));
+  const fetched = values.from ? await fetchFrom(String(values.from)) : void 0;
+  try {
+    const entries = fetched ? fetched.entries : await collect();
+    if (values.list) return void await list(entries);
+    const query = positionals[0];
+    if (!query) {
+      await list(entries);
+      process.exitCode = 1;
+      return;
+    }
+    const entry = find(entries, query) ?? fail(`Generator "${query}" not found \u2013 jen --list shows all.`);
+    const gen = await entry.load();
+    console.log(dim(`${qualified(entry)} (${entry.source})${gen.description ? ` \u2013 ${gen.description}` : ""}`));
+    const given = Object.fromEntries(Object.entries(values).filter(([k]) => !(k in FLAGS)));
+    const actions = gen.kind === "yeoman" ? await gen.run(given, positionals.slice(1)) : gen.actions(resolveParams(gen.params ?? {}, given), helpers);
+    const { steps, changes } = await plan(actions, Boolean(values.force));
+    console.log();
+    printPlan(steps);
+    if (changes.size === 0) return void console.log("\nNothing to do.");
+    if (values["dry-run"]) return;
+    const { written, deleted } = await apply(changes);
+    const summary = [written && `${written} written`, deleted && `${deleted} deleted`].filter(Boolean).join(", ");
+    console.log(styleText2("green", `\u2713 ${summary || "nothing changed"}`));
+  } finally {
+    fetched?.cleanup();
+  }
+}
+
+// src/jen.ts
+var isMain = (() => {
+  try {
+    return realpathSync(process.argv[1] ?? "") === import.meta.filename;
+  } catch {
+    return false;
+  }
+})();
+if (isMain) {
+  main().catch((e) => {
+    console.error(styleText3("red", e instanceof Error ? e.message : String(e)));
+    process.exitCode = 1;
+  });
+}
+export {
+  helpers
+};

package/dist/location.d.ts

@@ -0,0 +1,5 @@
+export declare function findUp(name: string, dir?: string): string | null;
+export declare const PROJECT_JEN: string | null;
+export declare let ROOT: string;
+export declare function setRoot(root: string): void;
+export declare const USER_DIR: string;

package/dist/yeoman.d.ts

@@ -0,0 +1,22 @@
+import type { Action } from './core.ts';
+interface YeomanGeneratorInstance {
+    run(): Promise<void>;
+}
+export type YeomanGeneratorClass = new (args: string[], options: Record<string, unknown>) => YeomanGeneratorInstance;
+export interface YeomanRunContext {
+    /** CLI-given values (as jen's own resolveParams sees them), used to answer this.prompt(). */
+    given: Record<string, unknown>;
+    /** Positionals after the generator name, forwarded as the generator's own positional arguments. */
+    positionals: string[];
+    /** Project root, used as the generator's destinationRoot/cwd. */
+    root: string;
+    /** Generator namespace, e.g. "code:app" – yeoman-generator requires one. */
+    namespace: string;
+}
+/**
+ * Instantiates and runs a real Yeoman generator class, faking just enough
+ * of a yeoman-environment for it to run, and returns the files it would
+ * write as jen actions – ready for jen's own plan()/apply().
+ */
+export declare function runYeoman(GeneratorClass: YeomanGeneratorClass, resolved: string, ctx: YeomanRunContext): Promise<Action[]>;
+export {};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@codejen/jen",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "bin": {
+    "jen": "./dist/jen.js"
+  },
+  "main": "./dist/jen.js",
+  "types": "./dist/jen.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/learosema/jen.git",
+    "directory": "packages/jen"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "rm -rf dist && esbuild src/jen.ts --bundle --platform=node --format=esm --target=node24 --outfile=dist/jen.js && tsc -p tsconfig.build.json && chmod +x dist/jen.js",
+    "typecheck": "tsc",
+    "test": "node --test jen.test.ts",
+    "prepublishOnly": "npm test && npm run typecheck && npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "esbuild": "^0.27.7",
+    "mem-fs": "^6.0.0",
+    "typescript": "^6.0.3",
+    "yeoman-generator": "^9.2.0"
+  }
+}