@aventara/cli 1.0.0-rc.11 → 1.0.0-rc.13

package/dist/command/command.parser.js

@@ -16,6 +16,12 @@ const OPTIONS = [
         commands: ["new"],
         summary: "create no git repository (passed to nest new)",
     },
+    {
+        flag: "--skip-lint",
+        key: "skipLint",
+        commands: ["new"],
+        summary: "leave out nest new's linter and formatter (oxlint, prettier, their files and scripts)",
+    },
     {
         flag: "--yes",
         alias: "-y",
@@ -236,6 +242,7 @@ export function parseCliCommand(argv) {
         given,
         skipInstall: options.skipInstall === true,
         skipGit: options.skipGit === true,
+        ...(options.skipLint === true ? { skipLint: true } : {}),
         yes: options.yes === true,
         ...(options.verbose === true ? { verbose: true } : {}),
         ...(host === undefined ? {} : { host }),

package/dist/plan/nest-host.planner.js

@@ -38,9 +38,8 @@ const E2E_SCRIPTS = {
 };
 const NEST = hostOf("nest");
 export function frontendInitCommand(packageManager, cliVersion) {
-    const tag = /^\d+\.\d+\.\d+-([0-9A-Za-z-]+)/.exec(cliVersion)?.[1];
     const runner = packageManager === "pnpm" ? "pnpm dlx" : "npx";
-    return `${runner} @aventara/client${tag === undefined ? "" : `@${tag}`} init`;
+    return `${runner} @aventara/client@${cliVersion} init`;
 }
 export function planNestHost(builder, input) {
     const { inspection, scaffold, packageManager } = input;
@@ -102,6 +101,7 @@ export function planNestHost(builder, input) {
             `pre${script}`,
             `${packageManager} run ${PREPARE_SCRIPT}`,
         ])),
+        typecheck: "tsc --noEmit",
         rewrites: inspection.usesNestConfig
             ? {}
             : {

package/dist/plan/next-host.planner.js

@@ -122,6 +122,7 @@ export function planNextHost(builder, input) {
         },
         build: "aventara-build --client",
         scripts: { prebuild: `${input.packageManager} run ${PREPARE_SCRIPT}` },
+        typecheck: "next typegen && tsc --noEmit",
         rewrites: {},
         gitignore: [
             `/${layout.generated}/`,

package/dist/plan/project.planner.js

@@ -1,4 +1,4 @@
-import { appendEnvEntryIfAbsent, mergeEnvFile, mergeGitignore, mergePackageManifest, mergePnpmWorkspace, } from "../apply/manifest.merger.js";
+import { allowBuildsEntries, allowBuildsGuidance, appendEnvEntryIfAbsent, mergeEnvFile, mergeGitignore, mergePackageManifest, mergePnpmWorkspace, } from "../apply/manifest.merger.js";
 import { planAgentSkill, SKILL_DIRECTORY, } from "../skill/agent-skill.planner.js";
 import { PREPARE_SCRIPT, } from "./host-plan.interface.js";
 import { planNestHost } from "./nest-host.planner.js";
@@ -16,6 +16,25 @@ function writeOf(path, before, after) {
             },
         ];
 }
+export function rootAllowBuilds(before, workspace, builds) {
+    if (!workspace.matched || builds.length === 0) {
+        return { kind: "none" };
+    }
+    const merged = mergePnpmWorkspace(before, builds);
+    if (merged.unsafe !== undefined) {
+        return {
+            kind: "print",
+            instruction: `The workspace root's ${workspace.file} was left as it is (${merged.unsafe}); add whichever of these are missing under your \`allowBuilds:\` (an explicit \`false\` is yours to keep):\n${allowBuildsEntries(builds)}`,
+        };
+    }
+    return merged.text === before
+        ? { kind: "none" }
+        : {
+            kind: "edit",
+            text: merged.text,
+            conflict: `the workspace root's ${workspace.file} (its allowBuilds gains ${merged.added.join(", ")}, for their install scripts)`,
+        };
+}
 export function planInit(input) {
     const { inspection, hosted, packageManager } = input;
     const { scaffold } = hosted;
@@ -93,10 +112,15 @@ export function planInit(input) {
             postinstall: `${packageManager} run ${PREPARE_SCRIPT}`,
             ...host.scripts,
         },
+        defaults: { typecheck: host.typecheck },
         rewrites: host.rewrites,
     }, replace));
     const env = input.read(".env");
     const { envEntry } = host;
+    const writesEnv = scaffoldWritesEnv ||
+        (envEntry !== undefined &&
+            env !== undefined &&
+            appendEnvEntryIfAbsent(env, envEntry.key, envEntry.value) !== env);
     if (scaffoldWritesEnv || (envEntry !== undefined && env !== undefined)) {
         builder.both(".env", env, (replace) => {
             const merged = scaffoldWritesEnv
@@ -114,15 +138,39 @@ export function planInit(input) {
     builder.both(".gitignore", gitignore, () => mergeGitignore(gitignore, [
         ...scaffold.gitignore,
         ...host.gitignore,
-        ...(scaffoldWritesEnv ? [".env"] : []),
+        ...(writesEnv ? [".env"] : []),
     ]));
-    if (packageManager === "pnpm" && scaffold.nativeBuilds.length > 0) {
-        const workspace = input.read("pnpm-workspace.yaml");
-        builder.both("pnpm-workspace.yaml", workspace, () => mergePnpmWorkspace(workspace, scaffold.nativeBuilds));
+    const { workspace } = input;
+    if (packageManager === "pnpm" && workspace !== undefined) {
+        const before = input.read(workspace.file);
+        const edit = rootAllowBuilds(before, workspace, scaffold.nativeBuilds);
+        if (edit.kind === "edit") {
+            builder.both(workspace.file, before, (replace) => ({
+                text: replace ? edit.text : (before ?? ""),
+                conflicts: [edit.conflict],
+            }));
+        }
+        else if (edit.kind === "print") {
+            builder.instruct(edit.instruction);
+        }
+        if (!workspace.matched) {
+            warnings.push(`${workspace.member} is not matched by the packages in ${workspace.file}, so pnpm install at the root does not install it; add it there`);
+        }
+    }
+    else if (packageManager === "pnpm" && scaffold.nativeBuilds.length > 0) {
+        const workspaceFile = input.read("pnpm-workspace.yaml");
+        const merged = mergePnpmWorkspace(workspaceFile, scaffold.nativeBuilds);
+        if (merged.unsafe === undefined) {
+            builder.both("pnpm-workspace.yaml", workspaceFile, () => merged);
+        }
+        else {
+            builder.instruct(`pnpm-workspace.yaml was left as it is (${merged.unsafe}); ${allowBuildsGuidance(workspaceFile, scaffold.nativeBuilds)}`);
+        }
     }
     const skill = planAgentSkill({
         read: input.read,
         coreVersion: input.aventaraVersion,
+        packageManager,
         force: false,
     });
     keeping.push(...skill.writes);

package/dist/project/pnpm-workspace.locator.js

@@ -0,0 +1,113 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+const WORKSPACE_FILE = "pnpm-workspace.yaml";
+function packagesOf(text) {
+    const lines = text.split("\n");
+    const at = lines.findIndex((line) => /^packages:\s*(\[.*\])?\s*$/.test(line));
+    if (at === -1) {
+        return [];
+    }
+    const unquote = (value) => value.trim().replace(/^["']|["']$/g, "");
+    const flow = /^packages:\s*\[(.*)\]\s*$/.exec(lines[at])?.[1];
+    if (flow !== undefined) {
+        return flow
+            .split(",")
+            .map(unquote)
+            .filter((value) => value !== "");
+    }
+    const globs = [];
+    for (let line = at + 1; line < lines.length; line += 1) {
+        const item = /^\s+-\s+(.+?)\s*(#.*)?$/.exec(lines[line]);
+        if (item === null) {
+            if (/^\S/.test(lines[line])) {
+                break;
+            }
+            continue;
+        }
+        globs.push(unquote(item[1]));
+    }
+    return globs;
+}
+function segmentPattern(part) {
+    let pattern = "";
+    for (let at = 0; at < part.length; at += 1) {
+        const char = part[at];
+        if (char === "*") {
+            pattern += "[^/]*";
+        }
+        else if (char === "?") {
+            pattern += "[^/]";
+        }
+        else if (char === "{") {
+            const close = part.indexOf("}", at);
+            if (close === -1) {
+                pattern += "\\{";
+                continue;
+            }
+            pattern += `(?:${part
+                .slice(at + 1, close)
+                .split(",")
+                .map(segmentPattern)
+                .join("|")})`;
+            at = close;
+        }
+        else {
+            pattern += char.replace(/[.+^$()|[\]\\]/g, "\\$&");
+        }
+    }
+    return pattern;
+}
+function globPattern(glob) {
+    const body = glob
+        .replace(/^\.\//, "")
+        .replace(/\/+$/, "")
+        .split("/")
+        .map((part) => (part === "**" ? "(?:.*)" : segmentPattern(part)))
+        .join("/");
+    return new RegExp(`^${body.replaceAll("/(?:.*)", "(?:/.*)?")}$`);
+}
+export function workspaceMatches(globs, member) {
+    let matched = false;
+    for (const glob of globs) {
+        if (glob.startsWith("!")) {
+            if (globPattern(glob.slice(1)).test(member)) {
+                matched = false;
+            }
+        }
+        else if (globPattern(glob).test(member)) {
+            matched = true;
+        }
+    }
+    return matched;
+}
+const LINT_CONFIG = /^(biome\.jsonc?|eslint\.config\.[cm]?[jt]s|\.eslintrc(\..+)?|\.prettierrc(\..+)?|prettier\.config\.[cm]?[jt]s)$/;
+export function enclosingPnpmWorkspace(directory) {
+    const project = path.resolve(directory);
+    let root = project;
+    for (;;) {
+        const file = path.join(root, WORKSPACE_FILE);
+        if (existsSync(file)) {
+            if (root === project) {
+                return undefined;
+            }
+            const member = path.relative(root, project).split(path.sep).join("/");
+            let entries = [];
+            try {
+                entries = readdirSync(root);
+            }
+            catch {
+            }
+            return {
+                root,
+                file: path.relative(project, file).split(path.sep).join("/"),
+                member,
+                matched: workspaceMatches(packagesOf(readFileSync(file, "utf8")), member),
+                lintConfigs: entries.filter((entry) => LINT_CONFIG.test(entry)).sort(),
+            };
+        }
+        if (root === path.dirname(root)) {
+            return undefined;
+        }
+        root = path.dirname(root);
+    }
+}

package/dist/project/project.inspector.js

@@ -13,7 +13,12 @@ const LOCKFILES = [
     ["package-lock.json", "npm"],
     ["pnpm-lock.yaml", "pnpm"],
     ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
 ];
+export function lockfilesIn(directory) {
+    return LOCKFILES.filter(([file]) => existsSync(path.join(directory, file))).map(([, manager]) => manager);
+}
 function dependencyRange(manifest, name) {
     return manifest.dependencies?.[name] ?? manifest.devDependencies?.[name];
 }
@@ -82,8 +87,8 @@ export function inspectProject(directory, catalog) {
         typescriptMajor >= FIRST_UNSUPPORTED_TYPESCRIPT) {
         throw new AvProjectRefusedError(`this project declares typescript ${typescript}, and TypeScript ${FIRST_UNSUPPORTED_TYPESCRIPT} has no classic compiler API for Aventara's generate steps to read types with; use TypeScript 5.7 to 6`);
     }
-    const lockfiles = LOCKFILES.filter(([file]) => existsSync(path.join(directory, file))).map(([, manager]) => manager);
-    const known = lockfiles.filter((manager) => manager !== "yarn");
+    const lockfiles = lockfilesIn(directory);
+    const known = lockfiles.filter((manager) => manager === "npm" || manager === "pnpm");
     if (lockfiles.includes("yarn") && known.length === 0) {
         throw new AvProjectRefusedError("this project has only a yarn.lock, and aventara init supports npm and pnpm");
     }

package/dist/release/newest-release.reader.js

@@ -0,0 +1,63 @@
+export function channelOf(version) {
+    return /-rc\.\d+$/.test(version) ? "rc" : "latest";
+}
+const PACKAGE = "@aventara/cli";
+const TIMEOUT_MS = 1500;
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+export function registryNewestRelease(registry) {
+    const base = registry === undefined || registry === "" ? DEFAULT_REGISTRY : registry;
+    return async (channel) => {
+        try {
+            const response = await fetch(new URL(`-/package/${PACKAGE.replace("/", "%2f")}/dist-tags`, base.endsWith("/") ? base : `${base}/`), { signal: AbortSignal.timeout(TIMEOUT_MS) });
+            if (!response.ok) {
+                return undefined;
+            }
+            const tags = (await response.json());
+            const named = tags[channel];
+            return typeof named === "string" ? named : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+function parse(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-rc\.(\d+))?$/.exec(version);
+    if (match === null) {
+        return undefined;
+    }
+    const [, major, minor, patch, rc] = match;
+    return {
+        core: [Number(major), Number(minor), Number(patch)],
+        ...(rc === undefined ? {} : { rc: Number(rc) }),
+    };
+}
+export function isNewer(candidate, pinned) {
+    const a = parse(candidate);
+    const b = parse(pinned);
+    if (a === undefined || b === undefined) {
+        return false;
+    }
+    for (let at = 0; at < 3; at += 1) {
+        const difference = a.core[at] - b.core[at];
+        if (difference !== 0) {
+            return difference > 0;
+        }
+    }
+    if (a.rc === undefined || b.rc === undefined) {
+        return a.rc === undefined && b.rc !== undefined;
+    }
+    return a.rc > b.rc;
+}
+export async function releaseLines(input) {
+    const newest = input.read === undefined
+        ? undefined
+        : await input.read(channelOf(input.pinned));
+    if (newest === undefined || !isNewer(newest, input.pinned)) {
+        return `Aventara ${input.pinned}\n`;
+    }
+    const take = input.packageManager === "pnpm"
+        ? `pnpm --config.minimum-release-age=0 dlx ${PACKAGE}@${newest} ${input.command} …`
+        : `npx ${PACKAGE}@${newest} ${input.command} …, with @aventara/* excluded from npm's min-release-age`;
+    return `Aventara ${input.pinned} (newest: ${newest}, held back by a release-age delay or not yet in your registry; to take it: ${take})\n`;
+}

package/dist/release/npm-registry.resolver.js

@@ -0,0 +1,120 @@
+import { closeSync, constants, existsSync, fstatSync, openSync, readSync, } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const SCOPE = "@aventara";
+export function npmRegistryOf(input) {
+    const scopeKey = `${SCOPE}:registry`;
+    const layers = [
+        environmentLayer(input.env),
+        fileLayer(path.join(localPrefixOf(input.cwd), ".npmrc"), undefined),
+        fileLayer(nonEmpty(input.env.npm_config_userconfig) ??
+            nonEmpty(input.env.NPM_CONFIG_USERCONFIG) ??
+            path.join(input.home ?? homedir(), ".npmrc"), input.env),
+    ];
+    for (const key of [scopeKey, "registry"]) {
+        for (const layer of layers) {
+            const value = layer.get(key);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+const KEYS = new Set([`${SCOPE}:registry`, "registry"]);
+const MAX_NPMRC_BYTES = 64 * 1024;
+function environmentLayer(env) {
+    const layer = new Map();
+    for (const key of KEYS) {
+        const value = nonEmpty(env[`npm_config_${key}`]) ??
+            nonEmpty(env[`NPM_CONFIG_${key.toUpperCase()}`]);
+        if (value === undefined) {
+            layer.delete(key);
+        }
+        else {
+            layer.set(key, value);
+        }
+    }
+    return layer;
+}
+function fileLayer(file, env) {
+    const layer = new Map();
+    const text = regularFileText(file);
+    if (text === undefined) {
+        return layer;
+    }
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        const equals = line.indexOf("=");
+        if (equals <= 0 || line.startsWith(";") || line.startsWith("#")) {
+            continue;
+        }
+        const key = line.slice(0, equals).trim();
+        if (!KEYS.has(key)) {
+            continue;
+        }
+        const written = unquote(line.slice(equals + 1).trim());
+        const value = nonEmpty(env === undefined
+            ? written.includes("${")
+                ? undefined
+                : written
+            : expand(written, env));
+        if (value === undefined) {
+            layer.delete(key);
+        }
+        else {
+            layer.set(key, value);
+        }
+    }
+    return layer;
+}
+function regularFileText(file) {
+    let descriptor;
+    try {
+        descriptor = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const stats = fstatSync(descriptor);
+        if (!stats.isFile() || stats.size > MAX_NPMRC_BYTES) {
+            return undefined;
+        }
+        const buffer = Buffer.alloc(MAX_NPMRC_BYTES + 1);
+        const read = readSync(descriptor, buffer, 0, buffer.length, 0);
+        return read > MAX_NPMRC_BYTES
+            ? undefined
+            : buffer.toString("utf8", 0, read);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function localPrefixOf(cwd) {
+    for (let at = path.resolve(cwd);; at = path.dirname(at)) {
+        if (existsSync(path.join(at, "package.json")) ||
+            existsSync(path.join(at, "node_modules"))) {
+            return at;
+        }
+        if (path.dirname(at) === at) {
+            return path.resolve(cwd);
+        }
+    }
+}
+function unquote(value) {
+    return value.length >= 2 &&
+        (value.startsWith('"') || value.startsWith("'")) &&
+        value.endsWith(value[0])
+        ? value.slice(1, -1)
+        : value;
+}
+function expand(value, env) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => env[name] ?? "");
+}
+function nonEmpty(value) {
+    return value === undefined || value === "" ? undefined : value;
+}

package/dist/run/init.orchestrator.js

@@ -4,6 +4,7 @@ import { confirmConflicts } from "../apply/conflict.confirmer.js";
 import { matchInstalledOrm, matchOrmSetup, } from "../catalog/catalog.matcher.js";
 import { planInit } from "../plan/project.planner.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
+import { enclosingPnpmWorkspace } from "../project/pnpm-workspace.locator.js";
 import { AvProjectRefusedError, inspectProject, } from "../project/project.inspector.js";
 import { scanServices } from "../project/service.detector.js";
 import { templatesFor } from "../templates/template.registry.js";
@@ -40,6 +41,9 @@ export async function initProject(command, io) {
         ? await prepareReuse(command, io, inspection, detectedPackageManager)
         : await prepareFresh(command, io, inspection, detectedPackageManager);
     const { entry, provider, hosted, packageManager } = prepared;
+    const workspace = packageManager === "pnpm"
+        ? enclosingPnpmWorkspace(io.directory)
+        : undefined;
     const plan = planInit({
         inspection,
         entry,
@@ -49,12 +53,17 @@ export async function initProject(command, io) {
         skipInstall: command.skipInstall,
         read,
         warnings: prepared.warnings,
+        ...(workspace === undefined ? {} : { workspace }),
     });
     await confirmConflicts(plan.conflicts, {
         yes: command.yes,
         prompter: io.prompter,
+        command: "init",
     });
     const writes = plan.conflicts.length === 0 ? plan.keeping : plan.replacing;
+    if (io.release !== undefined) {
+        io.stdout(await io.release());
+    }
     const progress = io.progress ??
         createStepReporter({
             write: io.stderr,
@@ -81,7 +90,7 @@ export async function initProject(command, io) {
     if (!command.skipInstall) {
         await progress.step(`Installing dependencies (${packageManager} install)`, async () => {
             const installed = await io.runner(packageManager, ["install"], {
-                cwd: io.directory,
+                cwd: workspace?.root ?? io.directory,
                 onOutput: progress.output,
             });
             if (installed.code !== 0) {

package/dist/run/new.orchestrator.js

@@ -1,10 +1,15 @@
 import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { confirmConflicts } from "../apply/conflict.confirmer.js";
+import { stripLintTooling } from "../apply/lint-tooling.stripper.js";
 import { DEFAULT_HOST, hostOf, } from "../catalog/host-entry.interface.js";
 import { AvCliCommandError, } from "../command/command.parser.js";
+import { rootAllowBuilds } from "../plan/project.planner.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
+import { enclosingPnpmWorkspace } from "../project/pnpm-workspace.locator.js";
 import { AvProjectRefusedError } from "../project/project.inspector.js";
+import { templatesFor, } from "../templates/template.registry.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
 import { NEW_QUESTIONS, } from "../wizard/wizard.questions.js";
 import { AvInstallFailedError, initProject, printNextSteps, } from "./init.orchestrator.js";
@@ -14,6 +19,7 @@ const NEST_CLI = "@nestjs/cli@12.0.8";
 const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
 const NEXT_VERSION_VARIABLE = "AVENTARA_NEXT_VERSION";
 const NEXT_GENERATOR = "create-next-app";
+const NEXT_MAJOR = "16";
 const VERSION = /^[0-9A-Za-z][0-9A-Za-z.+-]*$/;
 const NEXT_LAYOUT_FLAGS = [
     "--ts",
@@ -58,14 +64,17 @@ const GENERATIONS = {
         };
     },
     next: ({ command, io, name, packageManager }) => {
+        if (command.skipLint === true) {
+            throw new AvCliCommandError("--skip-lint takes out nest new's linter and formatter; create-next-app asks about its own linter, so answer it there or pass its flag after --");
+        }
         const pinned = io.env[NEXT_VERSION_VARIABLE];
         if (pinned !== undefined && pinned !== "" && !VERSION.test(pinned)) {
-            throw new AvCliCommandError(`${NEXT_VERSION_VARIABLE} is ${JSON.stringify(pinned)}, which is not a version of ${NEXT_GENERATOR}; set it to one such as 16.4.0, or unset it for the latest`);
+            throw new AvCliCommandError(`${NEXT_VERSION_VARIABLE} is ${JSON.stringify(pinned)}, which is not a version of ${NEXT_GENERATOR}; set it to one such as 16.4.0, or unset it for the newest ${NEXT_MAJOR}.x`);
         }
         if (!command.yes && !io.prompter.interactive) {
             throw new AvCliCommandError(`${NEXT_GENERATOR} asks its own questions, and nobody can answer them here (stdin is not a terminal); pass --yes to take its defaults, and its own flags after --`);
         }
-        const generator = `${NEXT_GENERATOR}@${pinned === undefined || pinned === "" ? "latest" : pinned}`;
+        const generator = `${NEXT_GENERATOR}@${pinned === undefined || pinned === "" ? NEXT_MAJOR : pinned}`;
         const [runner, prefix] = oneOff(packageManager);
         return {
             title: `Creating the Next.js project (${runner} ${[...prefix, generator, name].join(" ")})`,
@@ -86,6 +95,9 @@ const GENERATIONS = {
         };
     },
 };
+function withoutRelease({ release: _, ...io }) {
+    return io;
+}
 export async function runNew(command, io) {
     const host = hostOf((command.host ?? DEFAULT_HOST));
     const answers = await resolveAnswers(NEW_QUESTIONS, {
@@ -106,8 +118,13 @@ export async function runNew(command, io) {
         packageManager === undefined) {
         throw new Error("the new questions settled without every answer");
     }
+    GENERATIONS[host.alias]({ command, io, name, packageManager });
+    const surroundings = command.skipGit
+        ? undefined
+        : await gitSurroundings(io.runner, io.cwd);
+    const skipGit = command.skipGit || surroundings === "inside-work-tree";
     const generation = GENERATIONS[host.alias]({
-        command,
+        command: { ...command, skipGit },
         io,
         name,
         packageManager,
@@ -116,15 +133,34 @@ export async function runNew(command, io) {
     if (existsSync(directory) && readdirSync(directory).length > 0) {
         throw new AvProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
     }
-    const surroundings = command.skipGit
-        ? undefined
-        : await gitSurroundings(io.runner, io.cwd);
+    const workspace = packageManager === "pnpm" ? enclosingPnpmWorkspace(directory) : undefined;
+    if (workspace !== undefined) {
+        const edit = rootAllowBuilds(readFileSync(path.join(workspace.root, "pnpm-workspace.yaml"), "utf8"), workspace, templatesFor(orm).providers[db]?.nativeBuilds ?? []);
+        if (edit.kind === "edit") {
+            await confirmConflicts([edit.conflict], {
+                yes: command.yes,
+                prompter: io.prompter,
+                command: "new",
+            });
+        }
+    }
+    if (io.release !== undefined) {
+        io.stdout(await io.release());
+    }
+    if (host.alias === "nest" &&
+        command.skipLint !== true &&
+        workspace !== undefined &&
+        workspace.lintConfigs.length > 0) {
+        io.stderr(`aventara: the workspace root has its own ${workspace.lintConfigs.join(", ")}; pass --skip-lint to leave out nest new's oxlint and prettier.\n`);
+    }
     const progress = createStepReporter({
         write: io.stderr,
         mode: io.progressMode,
         total: (generation.interactive ? 1 : 2) +
             (command.skipInstall ? 0 : 1) +
-            (command.skipGit ? 0 : 1),
+            (surroundings === undefined || surroundings === "inside-work-tree"
+                ? 0
+                : 1),
         verbose: command.verbose === true,
     });
     const generate = async () => {
@@ -148,6 +184,9 @@ export async function runNew(command, io) {
         await progress.step(generation.title, generate);
     }
     generation.check(directory);
+    if (command.skipLint === true) {
+        stripLintTooling(directory);
+    }
     const { nextSteps } = await initProject({
         command: "init",
         given: {
@@ -159,11 +198,14 @@ export async function runNew(command, io) {
         skipGit: false,
         yes: true,
     }, {
-        ...io,
+        ...withoutRelease(io),
         directory,
         progress,
     });
-    if (surroundings !== undefined) {
+    if (surroundings === "inside-work-tree") {
+        io.stdout(`aventara: ${await commitScaffold(io.runner, directory, surroundings, io.cwd)}.\n`);
+    }
+    else if (surroundings !== undefined) {
         const committed = await progress.step("Committing the scaffold", () => commitScaffold(io.runner, directory, surroundings, io.cwd));
         io.stdout(`aventara: ${committed}.\n`);
     }

package/dist/run/skill.orchestrator.js

@@ -1,9 +1,22 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { detectPackageManager } from "../project/package-manager.detector.js";
+import { lockfilesIn } from "../project/project.inspector.js";
 import { planAgentSkill } from "../skill/agent-skill.planner.js";
 export class AvSkillRefusedError extends Error {
     name = "AvSkillRefusedError";
 }
+function lockfileManager(directory) {
+    for (let at = directory;; at = path.dirname(at)) {
+        const found = lockfilesIn(at);
+        if (found.length > 0) {
+            return found.find((manager) => manager === "npm" || manager === "pnpm");
+        }
+        if (path.dirname(at) === at || existsSync(path.join(at, ".git"))) {
+            return undefined;
+        }
+    }
+}
 function readText(file) {
     try {
         return readFileSync(file, "utf8");
@@ -34,6 +47,10 @@ export function runSkill(command, io) {
     const plan = planAgentSkill({
         read: (file) => readText(path.join(io.directory, file)),
         coreVersion,
+        packageManager: detectPackageManager({
+            lockfile: lockfileManager(io.directory),
+            userAgent: io.env?.npm_config_user_agent,
+        }),
         ...(errors === undefined ? {} : { errors }),
         force: command.force,
     });