@aventara/cli 0.0.0-stage → 0.1.0-pilot.1

package/dist/project/service.detector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * R6 — finding the developer's own ORM service, lexically, over `src/**\/*.ts`:
+ * no compiler (`aventara init` may run before anything is installed).
+ *
+ * 1. **Candidates**: exported classes that `extends` the ORM's client class,
+ *    where the file imports that class from a specifier the ORM's templates
+ *    recognise (the generated client, or the ORM package).
+ * 2. **Compositions**: exported classes that hold a client instead of extending
+ *    one (`client = new PrismaClient(…)`, Phase 11 S7's shape) — reported with
+ *    the member, never wired.
+ * 3. **Modules**: each `@Module({…})`-decorated exported class with the
+ *    identifiers its `providers` and `exports` list, and whether it is `@Global()`.
+ *
+ * Which of them is *the* service is the caller's question (the wizard's).
+ */
+export type ExportReference = {
+    /** Relative to the project root, POSIX separators. */
+    readonly file: string;
+    readonly exportName: string;
+};
+export type ServiceComposition = ExportReference & {
+    /** The member that holds the client. */
+    readonly member: string;
+};
+export type ModuleDeclaration = ExportReference & {
+    readonly providers: readonly string[];
+    readonly exports: readonly string[];
+    readonly global: boolean;
+};
+export type ServiceScan = {
+    readonly candidates: readonly ExportReference[];
+    readonly compositions: readonly ServiceComposition[];
+    readonly modules: readonly ModuleDeclaration[];
+};
+export type ClientShape = {
+    /** The client class a service extends, e.g. the ORM's generated client. */
+    readonly clientClass: string;
+    /** Whether `specifier`, imported by `file` (project-relative), is the client's module. */
+    readonly importsClient: (specifier: string, file: string) => boolean;
+    /** Directories under `src/` that hold generated code, skipped. */
+    readonly skip: readonly string[];
+};
+export declare function scanServices(directory: string, shape: ClientShape): ServiceScan;
+/** The modules that make `service` injectable elsewhere: providing and exporting it, or global. */
+export declare function modulesProviding(scan: ServiceScan, service: ExportReference): readonly ModuleDeclaration[];

package/dist/project/service.detector.js

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { closing, codeIndexes, codeMask, nextCode, OPENERS, } from "./source.scanner.js";
+function sourceFiles(directory, root, skip) {
+    if (!existsSync(directory)) {
+        return [];
+    }
+    return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+        const full = path.join(directory, entry.name);
+        const relative = path.relative(root, full).split(path.sep).join("/");
+        if (entry.isDirectory()) {
+            return entry.name === "node_modules" || skip.includes(relative)
+                ? []
+                : sourceFiles(full, root, skip);
+        }
+        return /\.ts$/.test(entry.name) && !/\.(spec|test|d)\.ts$/.test(entry.name)
+            ? [relative]
+            : [];
+    });
+}
+/** The identifiers the array under `key`, at `object`'s own level, names (`providers: [A, B]`). */
+function arrayNames(text, code, object, key) {
+    const end = closing(text, code, object);
+    let depth = 0;
+    for (let at = object + 1; at < end; at += 1) {
+        if (!code[at]) {
+            continue;
+        }
+        const char = text[at];
+        if (OPENERS[char] !== undefined) {
+            depth += 1;
+        }
+        else if (char === ")" || char === "]" || char === "}") {
+            depth -= 1;
+        }
+        else if (depth === 0 &&
+            text.startsWith(key, at) &&
+            !/[\w$]/.test(text[at - 1]) &&
+            /^\s*:/.test(text.slice(at + key.length))) {
+            const open = nextCode(text, code, text.indexOf(":", at) + 1);
+            if (text[open] !== "[") {
+                return [];
+            }
+            return text
+                .slice(open + 1, closing(text, code, open))
+                .split(",")
+                .map((item) => item.trim())
+                .filter((item) => /^[A-Za-z_$][\w$]*$/.test(item));
+        }
+    }
+    return [];
+}
+export function scanServices(directory, shape) {
+    const candidates = [];
+    const compositions = [];
+    const modules = [];
+    for (const file of sourceFiles(path.join(directory, "src"), directory, shape.skip)) {
+        const text = readFileSync(path.join(directory, file), "utf8");
+        const code = codeMask(text);
+        const importsClient = [
+            ...text.matchAll(new RegExp(`^import\\s*\\{[^}]*\\b${shape.clientClass}\\b[^}]*\\}\\s*from\\s*['"]([^'"]+)['"]`, "gm")),
+        ].some((match) => code[match.index] && shape.importsClient(match[1], file));
+        for (const match of text.matchAll(/^export\s+class\s+([A-Za-z_$][\w$]*)([^{]*)\{/gm)) {
+            if (!code[match.index]) {
+                continue;
+            }
+            const exportName = match[1];
+            const heritage = match[2];
+            if (importsClient &&
+                new RegExp(`\\bextends\\s+${shape.clientClass}\\b`).test(heritage)) {
+                candidates.push({ file, exportName });
+                continue;
+            }
+            const bodyStart = match.index + match[0].length - 1;
+            const body = text.slice(bodyStart, closing(text, code, bodyStart));
+            const held = new RegExp(`([A-Za-z_$][\\w$]*)\\s*(?::\\s*${shape.clientClass}\\b[^=;]*)?=\\s*new\\s+${shape.clientClass}\\s*\\(`).exec(body);
+            if (importsClient && held !== null) {
+                compositions.push({ file, exportName, member: held[1] });
+            }
+        }
+        for (const decorator of codeIndexes(text, code, /@Module\s*\(/g)) {
+            const open = text.indexOf("(", decorator);
+            const object = nextCode(text, code, open + 1);
+            const close = closing(text, code, open);
+            const declared = /^\s*(?:@[\w$.]+\([^)]*\)\s*)*export\s+class\s+([A-Za-z_$][\w$]*)/.exec(text.slice(close + 1));
+            if (text[object] !== "{" || declared === null) {
+                continue;
+            }
+            const before = text.slice(Math.max(0, decorator - 200), decorator);
+            modules.push({
+                file,
+                exportName: declared[1],
+                providers: arrayNames(text, code, object, "providers"),
+                exports: arrayNames(text, code, object, "exports"),
+                global: /@Global\s*\(\s*\)\s*$/.test(before) ||
+                    /^\s*@Global\s*\(\s*\)/.test(text.slice(close + 1)),
+            });
+        }
+    }
+    return { candidates, compositions, modules };
+}
+/** The modules that make `service` injectable elsewhere: providing and exporting it, or global. */
+export function modulesProviding(scan, service) {
+    return scan.modules.filter((module) => module.providers.includes(service.exportName) &&
+        (module.exports.includes(service.exportName) || module.global));
+}

package/dist/project/source.scanner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A lexical view of TypeScript source — enough to find decorators, classes,
+ * imports and brackets **in code**, never inside a comment, a string or a
+ * template literal's text — with no compiler: `aventara new` runs before
+ * anything (TypeScript included) is installed in the project, and the CLI
+ * carries no TypeScript of its own. Shared by the anchored `app.module.ts` edit
+ * and the detection of a developer's ORM service.
+ */
+/** For each character: is it code (not inside a comment, string or template text)? */
+export declare function codeMask(text: string): boolean[];
+/** Every index where `token` starts in code. */
+export declare function codeIndexes(text: string, code: boolean[], token: RegExp): number[];
+export declare const OPENERS: Readonly<Record<string, string>>;
+/** The index of the bracket closing the one at `open`, counting code brackets only. */
+export declare function closing(text: string, code: boolean[], open: number): number;
+export declare function nextCode(text: string, code: boolean[], from: number): number;

package/dist/project/source.scanner.js

@@ -0,0 +1,134 @@
+/**
+ * A lexical view of TypeScript source — enough to find decorators, classes,
+ * imports and brackets **in code**, never inside a comment, a string or a
+ * template literal's text — with no compiler: `aventara new` runs before
+ * anything (TypeScript included) is installed in the project, and the CLI
+ * carries no TypeScript of its own. Shared by the anchored `app.module.ts` edit
+ * and the detection of a developer's ORM service.
+ */
+/** For each character: is it code (not inside a comment, string or template text)? */
+export function codeMask(text) {
+    const code = new Array(text.length).fill(true);
+    /** Open template literals' brace depths: `${` re-enters code until its `}`. */
+    const templates = [];
+    let braces = 0;
+    let index = 0;
+    const mark = (from, to) => {
+        for (let at = from; at < to && at < text.length; at += 1) {
+            code[at] = false;
+        }
+    };
+    const templateText = (from) => {
+        // Scans template text from `from` until "`" (closes) or "${" (re-enters code).
+        let at = from;
+        while (at < text.length) {
+            if (text[at] === "\\") {
+                at += 2;
+                continue;
+            }
+            if (text[at] === "`") {
+                mark(from, at + 1);
+                return at + 1;
+            }
+            if (text[at] === "$" && text[at + 1] === "{") {
+                mark(from, at + 2);
+                templates.push(braces);
+                braces += 1;
+                return at + 2;
+            }
+            at += 1;
+        }
+        mark(from, at);
+        return at;
+    };
+    while (index < text.length) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (char === "/" && next === "/") {
+            const end = text.indexOf("\n", index);
+            const stop = end === -1 ? text.length : end;
+            mark(index, stop);
+            index = stop;
+        }
+        else if (char === "/" && next === "*") {
+            const end = text.indexOf("*/", index + 2);
+            const stop = end === -1 ? text.length : end + 2;
+            mark(index, stop);
+            index = stop;
+        }
+        else if (char === "'" || char === '"') {
+            let at = index + 1;
+            while (at < text.length && text[at] !== char && text[at] !== "\n") {
+                at += text[at] === "\\" ? 2 : 1;
+            }
+            mark(index, at + 1);
+            index = at + 1;
+        }
+        else if (char === "`") {
+            index = templateText(index);
+        }
+        else if (char === "{") {
+            braces += 1;
+            index += 1;
+        }
+        else if (char === "}") {
+            braces -= 1;
+            if (templates.length > 0 && templates[templates.length - 1] === braces) {
+                templates.pop();
+                code[index] = false;
+                index = templateText(index + 1);
+            }
+            else {
+                index += 1;
+            }
+        }
+        else {
+            index += 1;
+        }
+    }
+    return code;
+}
+/** Every index where `token` starts in code. */
+export function codeIndexes(text, code, token) {
+    const found = [];
+    for (const match of text.matchAll(token)) {
+        if (code[match.index]) {
+            found.push(match.index);
+        }
+    }
+    return found;
+}
+export const OPENERS = {
+    "(": ")",
+    "[": "]",
+    "{": "}",
+};
+/** The index of the bracket closing the one at `open`, counting code brackets only. */
+export function closing(text, code, open) {
+    const stack = [];
+    for (let at = open; at < text.length; at += 1) {
+        if (!code[at]) {
+            continue;
+        }
+        const char = text[at];
+        if (OPENERS[char] !== undefined) {
+            stack.push(OPENERS[char]);
+        }
+        else if (char === ")" || char === "]" || char === "}") {
+            if (stack.pop() !== char) {
+                return -1;
+            }
+            if (stack.length === 0) {
+                return at;
+            }
+        }
+    }
+    return -1;
+}
+export function nextCode(text, code, from) {
+    let at = from;
+    while (at < text.length && (!code[at] || /\s/.test(text[at]))) {
+        at += 1;
+    }
+    return at;
+}

package/dist/run/command.runner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The one external process seam (§4.2): a command, its arguments, a working
+ * directory. Its stdout is always **piped**, never inherited — `nest new` asks a
+ * question it has no flag for when its stdout is a terminal (B25) — and both
+ * streams are collected, so a failure can be reported with what it said.
+ */
+export type CommandResult = {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export type CommandRunner = (command: string, args: readonly string[], options: {
+    readonly cwd: string;
+}) => Promise<CommandResult>;
+export declare const runCommand: CommandRunner;

package/dist/run/command.runner.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+export const runCommand = (command, args, options) => new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+        cwd: options.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+        stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("close", (code) => {
+        resolve({ code: code ?? 1, stdout, stderr });
+    });
+});

package/dist/run/init.orchestrator.d.ts

@@ -0,0 +1,29 @@
+import type { AdapterCatalog } from "../catalog/catalog-entry.interface.js";
+import type { ScaffoldCommand } from "../command/command.parser.js";
+import { type Prompter } from "../wizard/answer.resolver.js";
+import type { CommandRunner } from "./command.runner.js";
+/**
+ * `aventara init` in §4.1's order — inspect, ask, plan, confirm, and only then
+ * write and install. Every step before the write reads; so a refusal anywhere
+ * before it leaves the project exactly as it was. A failure after it (the
+ * install) names the command, its exit code and what to re-run; nothing is
+ * rolled back.
+ */
+export type InitIo = {
+    readonly directory: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly stdout: (text: string) => void;
+    readonly stderr: (text: string) => void;
+    readonly prompter: Prompter;
+    readonly runner: CommandRunner;
+    readonly catalog: AdapterCatalog;
+    /** This CLI's own version (D1). */
+    readonly aventaraVersion: string;
+    /** Next steps that come before init's own (`new`'s `cd <name>`). */
+    readonly firstSteps?: readonly string[];
+};
+/** The install step failed after the files were written. Reported, exit 1. */
+export declare class InstallFailedError extends Error {
+    readonly name = "InstallFailedError";
+}
+export declare function runInit(command: ScaffoldCommand, io: InitIo): Promise<number>;

package/dist/run/init.orchestrator.js

@@ -0,0 +1,222 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+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 { inspectProject, ProjectRefusedError, } from "../project/project.inspector.js";
+import { scanServices } from "../project/service.detector.js";
+import { templatesFor, } from "../templates/template.registry.js";
+import { resolveAnswers } from "../wizard/answer.resolver.js";
+import { INIT_QUESTIONS, REUSE_QUESTIONS, } from "../wizard/wizard.questions.js";
+/** The install step failed after the files were written. Reported, exit 1. */
+export class InstallFailedError extends Error {
+    name = "InstallFailedError";
+}
+export async function runInit(command, io) {
+    const inspection = inspectProject(io.directory, io.catalog);
+    const read = (file) => {
+        try {
+            return readFileSync(path.join(io.directory, file), "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const detectedPackageManager = detectPackageManager({
+        lockfile: inspection.lockfile,
+        userAgent: io.env.npm_config_user_agent,
+    });
+    const prepared = inspection.orm.kind === "present"
+        ? await prepareReuse(command, io, inspection, detectedPackageManager)
+        : await prepareFresh(command, io, inspection, detectedPackageManager);
+    const { entry, provider, scaffold, packageManager } = prepared;
+    const plan = planInit({
+        inspection,
+        entry,
+        scaffold,
+        packageManager,
+        aventaraVersion: io.aventaraVersion,
+        skipInstall: command.skipInstall,
+        read,
+        ...(prepared.wiringByHand === undefined
+            ? {}
+            : { wiringByHand: prepared.wiringByHand }),
+        warnings: prepared.warnings,
+    });
+    await confirmConflicts(plan.conflicts, {
+        yes: command.yes,
+        prompter: io.prompter,
+    });
+    const writes = plan.conflicts.length === 0 ? plan.keeping : plan.replacing;
+    // The only file I/O (§4.1 `apply`).
+    for (const write of writes) {
+        const target = path.join(io.directory, write.path);
+        mkdirSync(path.dirname(target), { recursive: true });
+        writeFileSync(target, write.content);
+    }
+    for (const warning of plan.warnings) {
+        io.stderr(`aventara: warning: ${warning}.\n`);
+    }
+    io.stdout(`aventara: initialized ${io.directory} for ${entry.orm.label} ${entry.orm.major} on ${provider}: ${writes
+        .map((write) => `${write.change === "create" ? "created" : "updated"} ${write.path}`)
+        .join(", ")}.\n`);
+    if (plan.instructions !== undefined) {
+        io.stdout(`${plan.instructions}\n`);
+    }
+    if (!command.skipInstall) {
+        io.stdout(`aventara: running ${packageManager} install…\n`);
+        const installed = await io.runner(packageManager, ["install"], {
+            cwd: io.directory,
+        });
+        if (installed.code !== 0) {
+            throw new InstallFailedError(`\`${packageManager} install\` exited with code ${installed.code} after the files were written; fix what it reports and run \`${packageManager} install\` again:\n${installed.stderr.trimEnd()}`);
+        }
+    }
+    io.stdout(`Next:\n${[...(io.firstSteps ?? []), ...plan.nextSteps].map((step, index) => `  ${index + 1}. ${step}`).join("\n")}\n`);
+    return 0;
+}
+/** S6 — no ORM: the ORM and database are asked, and the entry's templates write it all. */
+async function prepareFresh(command, io, inspection, detectedPackageManager) {
+    const answers = await resolveAnswers(INIT_QUESTIONS, {
+        given: command.given,
+        yes: command.yes,
+        prompter: io.prompter,
+        context: { catalog: io.catalog, detectedPackageManager },
+    });
+    const { orm: entry, db, packageManager } = answers;
+    if (entry === undefined || db === undefined || packageManager === undefined) {
+        throw new Error("the init questions settled without an ORM, database and package manager");
+    }
+    return {
+        entry,
+        provider: db,
+        packageManager,
+        scaffold: templatesFor(entry).scaffold({
+            entry,
+            provider: db,
+            moduleKind: inspection.moduleKind,
+            packageManager,
+        }),
+        warnings: [],
+    };
+}
+/** The installed version of `name`, looked up the way Node resolves it: upward from the project. */
+function installedVersion(directory, name) {
+    let current = directory;
+    for (;;) {
+        const manifest = path.join(current, "node_modules", name, "package.json");
+        if (existsSync(manifest)) {
+            const version = JSON.parse(readFileSync(manifest, "utf8")).version;
+            return typeof version === "string" ? version : undefined;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+/**
+ * S7 — the ORM is already set up (R6, R7): the catalog entry is matched against
+ * what is installed, the setup against what the entry declares, and the
+ * developer's own service is found or asked for. Nothing of theirs is written.
+ */
+async function prepareReuse(command, io, inspection, detectedPackageManager) {
+    const dependencies = [
+        ...Object.keys(inspection.manifest.dependencies ?? {}),
+        ...Object.keys(inspection.manifest.devDependencies ?? {}),
+    ];
+    const verdict = matchInstalledOrm(io.catalog, {
+        dependencies,
+        installedVersion: (name) => installedVersion(io.directory, name),
+        installCommand: `${detectedPackageManager} install`,
+    });
+    if (verdict.kind === "refused") {
+        throw new ProjectRefusedError(verdict.sentence);
+    }
+    const { entry } = verdict;
+    const templates = templatesFor(entry);
+    const facts = templates.readProject(io.directory, inspection.manifest);
+    const problem = matchOrmSetup(entry, facts);
+    if (problem !== undefined) {
+        throw new ProjectRefusedError(problem);
+    }
+    const provider = facts.provider;
+    if (facts.clientOutput === undefined) {
+        throw new ProjectRefusedError(`this project's ${facts.generator} generator block in ${facts.schema} has no output, and the generate step reads the client from it; give it one, such as ../src/generated/${entry.orm.family}`);
+    }
+    // A flag naming the ORM or database must name what the project has.
+    for (const [flag, given, found] of [
+        ["--orm", command.given.orm, `${entry.orm.family}@${entry.orm.major}`],
+        ["--db", command.given.db, provider],
+    ]) {
+        if (given !== undefined &&
+            given.trim().toLowerCase() !== found &&
+            !(flag === "--orm" && given.trim().toLowerCase() === entry.orm.family)) {
+            throw new ProjectRefusedError(`${flag} ${given} does not match this project, which already uses ${found}`);
+        }
+    }
+    const scan = scanServices(io.directory, templates.clientShape(facts));
+    const answers = await resolveAnswers(REUSE_QUESTIONS, {
+        given: command.given,
+        yes: command.yes,
+        prompter: io.prompter,
+        context: {
+            catalog: io.catalog,
+            detectedPackageManager,
+            services: {
+                scan,
+                clientClass: templates.clientShape(facts).clientClass,
+                newService: templates.newService.service,
+                newModule: templates.newService.module,
+                newServiceFileExists: existsSync(path.join(io.directory, templates.newService.service.file)),
+                label: entry.orm.label,
+            },
+        },
+    });
+    const { service, module, packageManager } = answers;
+    if (service === undefined ||
+        module === undefined ||
+        packageManager === undefined) {
+        throw new Error("the reuse questions settled without a service, module and package manager");
+    }
+    // Q16-21: beside the client's output, unless that output contains it (the adapter refuses that).
+    const preferred = "src/generated/aventara/discovery.artifact.ts";
+    const artifact = `${preferred}/`.startsWith(`${facts.clientOutput}/`)
+        ? "src/aventara/discovery.artifact.ts"
+        : preferred;
+    const warnings = [
+        ...(facts.clientOutput.startsWith("src/")
+            ? []
+            : [
+                `the ${entry.orm.label} client is generated into ${facts.clientOutput}, outside src/, which nest build does not compile (B6); your build is your own, and init does not change it`,
+            ]),
+        ...(service.clientMember === undefined
+            ? []
+            : [
+                `${service.file}#${service.exportName} holds its client in .${service.clientMember} instead of extending ${templates.clientShape(facts).clientClass}, so src/aventara.config.ts passes ${service.exportName}.${service.clientMember}`,
+            ]),
+    ];
+    return {
+        entry,
+        provider,
+        packageManager,
+        scaffold: templates.reuse({
+            entry,
+            facts: { ...facts, provider, clientOutput: facts.clientOutput },
+            moduleKind: inspection.moduleKind,
+            packageManager,
+            service,
+            module,
+            writeService: service.isNew,
+            artifact,
+        }),
+        ...(service.clientMember === undefined
+            ? {}
+            : {
+                wiringByHand: `${service.exportName} holds its ${entry.orm.label} client instead of extending it`,
+            }),
+        warnings,
+    };
+}

package/dist/run/new.orchestrator.d.ts

@@ -0,0 +1,21 @@
+import type { ScaffoldCommand } from "../command/command.parser.js";
+import { type InitIo } from "./init.orchestrator.js";
+/**
+ * `aventara new <name>` (R2, D1): the pinned `nest new`, then **exactly**
+ * `aventara init`'s pipeline over the fresh project, with the wizard's answers
+ * carried in — so every `new` run exercises the anchored edit, the merges and
+ * the templates `init` uses.
+ *
+ * Nest authors its own scaffold (D1): the CLI never writes Nest's files. Its
+ * output is pinned by digest (B24), so a `@nestjs/cli` that writes something
+ * else stops the run before anything of Aventara's is written over it.
+ */
+/** D1: the `nest new` this CLI was measured against (B1, B24). */
+export declare const NEST_CLI = "@nestjs/cli@12.0.8";
+/** B24: `src/app.module.ts` as `@nestjs/cli` 12.0.8 writes it — the anchored edit's file. */
+export declare const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
+export type NewIo = Omit<InitIo, "directory"> & {
+    /** Where `new` creates the project directory. */
+    readonly cwd: string;
+};
+export declare function runNew(command: ScaffoldCommand, io: NewIo): Promise<number>;