@pristine-ts/cli 1.0.440 → 2.0.2

package/dist/types/bootstrap/bootstrap.d.ts

@@ -0,0 +1,14 @@
+export * from "./app-module-loader";
+export * from "./build-manifest";
+export * from "./build-manifest-checker";
+export * from "./build-manifest-reader";
+export * from "./build-manifest-staleness.enum";
+export * from "./build-manifest-writer";
+export * from "./build-runner";
+export * from "./build-staleness-prompt";
+export * from "./dynamic-importer";
+export * from "./init-prompt";
+export * from "./loaded-app-module";
+export * from "./loaded-plugin";
+export * from "./plugin-loader";
+export * from "./source-hasher";

package/dist/types/bootstrap/build-manifest-checker.d.ts

@@ -0,0 +1,19 @@
+import { BuildManifest } from "./build-manifest";
+import { BuildManifestStalenessEnum } from "./build-manifest-staleness.enum";
+import { SourceHasher } from "./source-hasher";
+/**
+ * Decides whether an existing `BuildManifest` still describes the current state of the
+ * project. Compares the manifest's stored paths/hash against the live config + source file
+ * + filesystem. Returns the most-specific reason the manifest is stale so the caller can
+ * render a helpful message ("source changed", "output missing", etc.) rather than a vague
+ * "stale".
+ *
+ * Order of checks matches user impact: things that mean "you definitely need to rebuild"
+ * (output missing, source content changed) come before path drift (config edited but build
+ * not yet rerun) — both are correct to flag, but the messaging differs.
+ */
+export declare class BuildManifestChecker {
+    private readonly sourceHasher;
+    constructor(sourceHasher: SourceHasher);
+    check(manifest: BuildManifest | undefined, projectRoot: string, configuredSourcePath: string, configuredOutputPath: string): BuildManifestStalenessEnum;
+}

package/dist/types/bootstrap/build-manifest-reader.d.ts

@@ -0,0 +1,14 @@
+import { BuildManifest } from "./build-manifest";
+/**
+ * Reads `<projectRoot>/.pristine/build-manifest.json` if present and returns a `BuildManifest`
+ * instance. Used by `AppModuleLoader` and `BuildManifestChecker` to inspect the last build.
+ *
+ * Returns `undefined` (not throws) when the manifest is missing — that's a normal state for
+ * fresh projects that haven't run `pristine build` yet. Genuine errors (corrupt JSON, IO
+ * failure) do throw, since silently treating those as "no manifest" would mask real problems.
+ */
+export declare class BuildManifestReader {
+    private readonly cacheDirName;
+    private readonly manifestFileName;
+    read(projectRoot: string): BuildManifest | undefined;
+}

package/dist/types/bootstrap/build-manifest-staleness.enum.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Why a build manifest is no longer trustworthy. Returned by `BuildManifestChecker` so the
+ * caller can render an error message specific to the actual cause rather than a vague "stale".
+ */
+export declare enum BuildManifestStalenessEnum {
+    /** Manifest is current — the build output matches what the config + source describe. */
+    Fresh = "fresh",
+    /** No manifest file on disk. The user hasn't run `pristine build` yet (or deleted the cache). */
+    Missing = "missing",
+    /** The configured `sourcePath` no longer matches the path stored in the manifest. */
+    SourcePathChanged = "source-path-changed",
+    /** The configured `outputPath` no longer matches the path stored in the manifest. */
+    OutputPathChanged = "output-path-changed",
+    /** The source file's content hash no longer matches what was hashed at build time. */
+    SourceContentChanged = "source-content-changed",
+    /** The compiled output file referenced by the manifest is missing from disk. */
+    OutputMissing = "output-missing"
+}

package/dist/types/bootstrap/build-manifest-writer.d.ts

@@ -0,0 +1,19 @@
+import { BuildManifest } from "./build-manifest";
+import { SourceHasher } from "./source-hasher";
+/**
+ * Writes the build manifest to `<projectRoot>/.pristine/build-manifest.json` atomically
+ * (write-then-rename) so a partial write can never poison subsequent reads. Used by
+ * `BuildCommand` after a successful compile.
+ *
+ * Atomicity matters: if `pristine build` is interrupted (Ctrl+C, OOM kill) mid-write, a
+ * half-written JSON file would make the next `pristine start` think the build was good but
+ * fail to parse the manifest. Renaming after a complete write ensures readers either see
+ * the previous manifest or the new one — never a torn one.
+ */
+export declare class BuildManifestWriter {
+    private readonly sourceHasher;
+    private readonly cacheDirName;
+    private readonly manifestFileName;
+    constructor(sourceHasher: SourceHasher);
+    write(projectRoot: string, sourcePath: string, outputPath: string): BuildManifest;
+}

package/dist/types/bootstrap/build-manifest.d.ts

@@ -0,0 +1,29 @@
+/**
+ * On-disk record of what `pristine build` produced. Written atomically at the end of a
+ * successful build to `.pristine/build-manifest.json`. Read by every downstream command that
+ * loads the AppModule (`pristine start`, `pristine verify`, etc.) so the loader can detect
+ * staleness — source file changed, config changed, output file missing — without scanning
+ * the filesystem.
+ *
+ * Plain class (no DI / no methods) because manifests serialize to/from JSON and the simpler
+ * the shape is, the harder it is to break the on-disk contract by accident.
+ */
+export declare class BuildManifest {
+    /** Absolute path to the AppModule source file as it was at build time. */
+    readonly appModuleSourcePath: string;
+    /** Absolute path to the compiled AppModule output file as it was at build time. */
+    readonly appModuleOutputPath: string;
+    /** SHA-256 of the source file contents at build time. Drives staleness detection. */
+    readonly sourceHash: string;
+    /** ISO-8601 timestamp of when the build completed. */
+    readonly builtAt: string;
+    constructor(
+    /** Absolute path to the AppModule source file as it was at build time. */
+    appModuleSourcePath: string, 
+    /** Absolute path to the compiled AppModule output file as it was at build time. */
+    appModuleOutputPath: string, 
+    /** SHA-256 of the source file contents at build time. Drives staleness detection. */
+    sourceHash: string, 
+    /** ISO-8601 timestamp of when the build completed. */
+    builtAt: string);
+}

package/dist/types/bootstrap/build-runner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runs `pristine p:build` as a subprocess of the currently-running bin. Used by
+ * `AppModuleLoader` when the user accepts the "rebuild now?" prompt — re-running the build
+ * inline avoids the awkward "exit, ask the user to type a command, re-enter" loop.
+ *
+ * Spawning rather than dispatching to `BuildCommand` directly keeps `AppModuleLoader` free
+ * of the build pipeline's dependency graph (ConsoleManager, ShellManager, etc.) which only
+ * exists in the kernel container — and the kernel hasn't booted yet at the point this is
+ * called. The subprocess re-bootstraps the kernel cleanly with all of those services.
+ *
+ * Returns `true` on a successful build (exit code 0), `false` on any failure or signal.
+ */
+export declare class BuildRunner {
+    private readonly buildCommandName;
+    run(): boolean;
+}

package/dist/types/bootstrap/build-staleness-prompt.d.ts

@@ -0,0 +1,27 @@
+import { BuildManifestStalenessEnum } from "./build-manifest-staleness.enum";
+import { DynamicImporter } from "./dynamic-importer";
+/**
+ * When the build manifest is stale (source edited, output missing, etc.), `AppModuleLoader`
+ * stops the load and consults this prompt. In a TTY, asks the user whether to run
+ * `pristine build` now; in non-TTY (CI, Docker), refuses to prompt and lets the caller exit
+ * non-zero with the explanation — auto-rebuilding in CI hides bugs.
+ *
+ * Just the prompt UI here. The actual rebuild dispatch is the caller's responsibility so
+ * this class stays small and testable.
+ */
+export declare class BuildStalenessPrompt {
+    private readonly dynamicImporter;
+    private readonly promptMessage;
+    constructor(dynamicImporter: DynamicImporter);
+    isInteractive(): boolean;
+    /**
+     * Renders a one-line explanation of why the manifest is stale. Used by both the prompt
+     * (TTY) and the non-TTY error path so the messaging is identical regardless of channel.
+     */
+    describe(reason: BuildManifestStalenessEnum): string;
+    /**
+     * Asks the user whether to rebuild. Returns `true` for yes, `false` for no, `undefined`
+     * for cancellation (Ctrl+C). Caller decides what to do with each outcome.
+     */
+    prompt(reason: BuildManifestStalenessEnum): Promise<boolean | undefined>;
+}

package/dist/types/bootstrap/dynamic-importer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wraps Node's real dynamic `import()` so it survives both tsc's CJS lowering and esbuild's
+ * bundling. Both transformations otherwise rewrite `await import(x)` to a `require(x)` call —
+ * which is wrong for ESM-only packages and for `file://` URLs. The Function constructor's body
+ * is opaque to both, so the `import()` inside it goes through unrewritten.
+ *
+ * Centralized in one class so the same escape hatch isn't reimplemented in every consumer
+ * (loaders, plugin discovery, config loading, etc.).
+ */
+export declare class DynamicImporter {
+    private readonly importFn;
+    import(specifier: string): Promise<any>;
+}

package/dist/types/bootstrap/init-prompt.d.ts

@@ -0,0 +1,38 @@
+import { DynamicImporter } from "./dynamic-importer";
+/**
+ * Answers the init flow needs to gather. Each field corresponds to one config value that
+ * `pristine.config.ts` will end up with. The init command resolves these from CLI flags
+ * first, then prompts (in TTY) for whatever's missing.
+ */
+export interface InitAnswers {
+    sourcePath: string;
+    outputPath: string;
+    tsconfig: string;
+    format: "esm" | "cjs" | "both";
+    scaffoldSource: boolean;
+    writePackageScripts: boolean;
+}
+/**
+ * Interactive Q&A for `pristine init`. Lazy-loads `@inquirer/prompts` so the dep cost is
+ * only paid when actually prompting (the same pattern as `BuildStalenessPrompt` uses).
+ *
+ * Each method takes a "current value" so callers can pre-fill answers from CLI flags and
+ * only prompt for the gaps. Returning the same value the user passed in is intentional —
+ * it keeps the call sites uniform regardless of whether the value came from a flag or a
+ * prompt.
+ */
+export declare class InitPrompt {
+    private readonly dynamicImporter;
+    private readonly defaultSourcePath;
+    private readonly defaultOutputPath;
+    private readonly defaultTsconfig;
+    private readonly defaultFormat;
+    constructor(dynamicImporter: DynamicImporter);
+    isInteractive(): boolean;
+    askSourcePath(current: string | undefined): Promise<string>;
+    askOutputPath(current: string | undefined): Promise<string>;
+    askTsconfig(current: string | undefined): Promise<string>;
+    askFormat(current: "esm" | "cjs" | "both" | undefined): Promise<"esm" | "cjs" | "both">;
+    askScaffoldSource(current: boolean | undefined, sourcePath: string): Promise<boolean>;
+    askWritePackageScripts(current: boolean | undefined): Promise<boolean>;
+}

package/dist/types/bootstrap/loaded-app-module.d.ts

@@ -0,0 +1,40 @@
+import { AppModuleInterface } from "@pristine-ts/common";
+import { ModuleConfigurationValue } from "@pristine-ts/configuration";
+import { LoadedPlugin } from "./loaded-plugin";
+/**
+ * The fully-resolved AppModule + ambient configuration that the CLI uses to boot the kernel.
+ * Returned by `AppModuleLoader.load()`.
+ */
+export declare class LoadedAppModule {
+    readonly appModule: AppModuleInterface;
+    readonly configuration: {
+        [key: string]: ModuleConfigurationValue;
+    };
+    /**
+     * True when `LoggingModule` is in the resolved AppModule's import graph. The CLI uses
+     * this to decide whether to layer in opinionated default logging configuration (Simple
+     * output mode, Error severity threshold) on top of the kernel configuration.
+     */
+    readonly isLoggingModulePresent: boolean;
+    /**
+     * Plugins loaded from `pristine.config.ts`'s `plugins` array. Empty when no plugins are
+     * declared. Carried through so commands like `pristine info` can show what's contributing
+     * extra modules to the runtime.
+     */
+    readonly plugins: LoadedPlugin[];
+    constructor(appModule: AppModuleInterface, configuration: {
+        [key: string]: ModuleConfigurationValue;
+    }, 
+    /**
+     * True when `LoggingModule` is in the resolved AppModule's import graph. The CLI uses
+     * this to decide whether to layer in opinionated default logging configuration (Simple
+     * output mode, Error severity threshold) on top of the kernel configuration.
+     */
+    isLoggingModulePresent: boolean, 
+    /**
+     * Plugins loaded from `pristine.config.ts`'s `plugins` array. Empty when no plugins are
+     * declared. Carried through so commands like `pristine info` can show what's contributing
+     * extra modules to the runtime.
+     */
+    plugins: LoadedPlugin[]);
+}

package/dist/types/bootstrap/loaded-plugin.d.ts

@@ -0,0 +1,20 @@
+import { ModuleInterface } from "@pristine-ts/common";
+/**
+ * A successfully-loaded plugin. Records the package name (for collision diagnostics), the
+ * absolute path it was resolved to, and every `*Module` export the plugin's entry produced.
+ */
+export declare class LoadedPlugin {
+    /** As declared in `pristine.config.ts` plugins[] (string form or `.name` form). */
+    readonly name: string;
+    /** Absolute path resolved by `createRequire` from the consumer's project. */
+    readonly resolvedPath: string;
+    /** Modules harvested from the plugin's exports — one entry per `*Module` named export. */
+    readonly modules: ModuleInterface[];
+    constructor(
+    /** As declared in `pristine.config.ts` plugins[] (string form or `.name` form). */
+    name: string, 
+    /** Absolute path resolved by `createRequire` from the consumer's project. */
+    resolvedPath: string, 
+    /** Modules harvested from the plugin's exports — one entry per `*Module` named export. */
+    modules: ModuleInterface[]);
+}

package/dist/types/bootstrap/plugin-loader.d.ts

@@ -0,0 +1,35 @@
+import { AppModuleInterface } from "@pristine-ts/common";
+import { PristineConfig } from "../config/pristine-config.interface";
+import { DynamicImporter } from "./dynamic-importer";
+import { LoadedPlugin } from "./loaded-plugin";
+/**
+ * Resolves and loads every plugin declared in `config.plugins`. Plugin packages are resolved
+ * from the **consumer's project**, not from the CLI's install location — a plugin lives in
+ * the consumer's `node_modules`, not in `@pristine-ts/cli/node_modules`. Without
+ * `createRequire` pinned to the project location, `import("@my-org/plugin")` would walk up
+ * from the bin's install dir and miss it.
+ *
+ * A plugin that fails to load surfaces as a thrown error rather than being silently skipped —
+ * silent plugin loading is a footgun that makes "why isn't my command showing up" debuggable
+ * only by reading source.
+ */
+export declare class PluginLoader {
+    private readonly dynamicImporter;
+    constructor(dynamicImporter: DynamicImporter);
+    load(config: PristineConfig, configFilePath: string | undefined, projectRoot: string): Promise<LoadedPlugin[]>;
+    /**
+     * Synthesizes an outer AppModule whose `importModules` includes the user's AppModule plus
+     * every plugin-contributed module, deduplicated by reference. Preserves the user's keyname
+     * (suffixed with `.with-plugins`) so introspection tools (`pristine info`) still surface a
+     * recognizable label.
+     */
+    wrap(appModule: AppModuleInterface, plugins: LoadedPlugin[]): AppModuleInterface;
+    private resolvePluginPath;
+    private importPlugin;
+    /**
+     * Walks a plugin's exports collecting every value whose name ends in `Module` and looks
+     * like a `ModuleInterface` (has a `keyname` string). Accepts both ESM (default export) and
+     * CJS (named exports on the module namespace) plugin shapes.
+     */
+    private harvestModuleExports;
+}

package/dist/types/bootstrap/source-hasher.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Computes the content hash that goes into the build manifest. SHA-256 because it's
+ * collision-free for our purposes, ships with Node, and the hex digest is short enough
+ * to pretty-print in error messages without truncating.
+ *
+ * The hash is just a fingerprint of the source file's bytes — no AST awareness, no
+ * imports-aware tracing. That's intentional: a deeper hash (e.g. of the whole source tree)
+ * adds complexity and IO without changing the staleness story for the common case (user
+ * edits app.module.ts → hash changes → CLI tells them to rebuild).
+ */
+export declare class SourceHasher {
+    private readonly algorithm;
+    private readonly digestPrefix;
+    hashFile(absolutePath: string): string;
+}

package/dist/types/cli.d.ts

@@ -1 +1,13 @@
+/**
+ * Boots the CLI: discovers the consumer's AppModule, starts the kernel, and dispatches
+ * `process.argv` to whichever command matches. Exported so `bin.ts` can call it explicitly
+ * — the auto-invoke at module load was removed so library consumers importing this file for
+ * its types or `bootstrap` reference do not accidentally trigger an entire kernel boot.
+ *
+ * The bootstrap-layer collaborators (loaders, discoverers, cache, prompt) are instantiated
+ * by hand here rather than resolved through DI. The kernel container does not exist yet at
+ * this point, so DI is not available — manually wiring the (small, stable) class graph is the
+ * least surprising option. Once the kernel is up, the kernel itself is registered into its
+ * own container so commands can inject it.
+ */
 export declare const bootstrap: () => Promise<void>;

package/dist/types/cli.module.d.ts

@@ -1,5 +1,7 @@
 import { ModuleInterface } from "@pristine-ts/common";
+export * from "./bootstrap/bootstrap";
 export * from "./commands/commands";
+export * from "./config/config";
 export * from "./enums/enums";
 export * from "./errors/errors";
 export * from "./event-handlers/event-handlers";
@@ -9,4 +11,5 @@ export * from "./managers/managers";
 export * from "./mappers/mappers";
 export * from "./options/options";
 export * from "./types/types";
+export { bootstrap } from "./cli";
 export declare const CliModule: ModuleInterface;

package/dist/types/commands/build-alias.command.d.ts

@@ -0,0 +1,15 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { BuildCommand } from "./build.command";
+/**
+ * Top-level alias for the framework-reserved `p:build` command. Injects the delegate
+ * directly via standard DI.
+ */
+export declare class BuildAliasCommand implements CommandInterface<null> {
+    private readonly delegate;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(delegate: BuildCommand);
+    run(args: any): Promise<ExitCodeEnum | number>;
+}

package/dist/types/commands/build.command.d.ts

@@ -0,0 +1,47 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ConsoleManager } from "../managers/console.manager";
+import { ShellManager } from "../managers/shell.manager";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { ConfigLoader } from "../config/config-loader";
+import { BuildManifestWriter } from "../bootstrap/build-manifest-writer";
+/**
+ * Compiles the consumer's TypeScript project. Reads `build.{outDir,tsconfig,format,clean}`
+ * and `appModule.{sourcePath,outputPath}` from `pristine.config.ts`. After a successful
+ * compile, writes a build manifest at `<projectRoot>/.pristine/build-manifest.json` so
+ * downstream commands (`pristine start`, `pristine verify`) can detect when the build is
+ * stale (source edited, output deleted, paths reconfigured).
+ *
+ * The manifest is only written when both `appModule.sourcePath` and `appModule.outputPath`
+ * are configured. Without both, there's nothing to fingerprint and downstream commands fall
+ * through to the next layer of the loader cascade.
+ *
+ * Defaults (when not configured):
+ *   - tsconfig: "tsconfig.json"
+ *   - format:   "esm"           (single tsc invocation)
+ *   - format:   "cjs"           (looks for tsconfig.cjs.json automatically)
+ *   - format:   "both"          (runs both invocations sequentially)
+ *   - outDir:   not set; tsc writes to whatever the tsconfig declares
+ *   - clean:    false           (set true to wipe outDir before building)
+ */
+export declare class BuildCommand implements CommandInterface<null> {
+    private readonly consoleManager;
+    private readonly shellManager;
+    private readonly configLoader;
+    private readonly buildManifestWriter;
+    optionsType: null;
+    name: string;
+    description: string;
+    private readonly defaultTsconfig;
+    private readonly defaultFormat;
+    constructor(consoleManager: ConsoleManager, shellManager: ShellManager, configLoader: ConfigLoader, buildManifestWriter: BuildManifestWriter);
+    run(args: any): Promise<ExitCodeEnum | number>;
+    private writeManifestIfConfigured;
+    /**
+     * For `format: "both"`, we run two passes: the primary tsconfig (assumed ESM-ish), then
+     * the `.cjs.json` sibling. For `cjs`/`esm`, we run only the matching one. Returns the
+     * absolute tsconfig paths in the order they should run.
+     * @private
+     */
+    private resolveTscInvocations;
+    private expectedTsconfigsForFormat;
+}

package/dist/types/commands/commands.d.ts

@@ -1,2 +1,17 @@
+export * from "./build-alias.command";
+export * from "./build.command";
+export * from "./config-print.command";
+export * from "./help-alias.command";
 export * from "./help.command";
+export * from "./info-alias.command";
+export * from "./info.command";
+export * from "./init-alias.command";
+export * from "./init.command";
+export * from "./init.command-options";
+export * from "./list-alias.command";
 export * from "./list.command";
+export * from "./start-alias.command";
+export * from "./start.command";
+export * from "./start.command-options";
+export * from "./verify-alias.command";
+export * from "./verify.command";

package/dist/types/commands/config-print.command.d.ts

@@ -0,0 +1,18 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ConsoleManager } from "../managers/console.manager";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { ConfigLoader } from "../config/config-loader";
+/**
+ * Prints the resolved Pristine configuration plus where it was loaded from. Useful for
+ * debugging discovery — when `pristine` is doing something unexpected, the first question is
+ * always "which config file did it actually pick up?"
+ */
+export declare class ConfigPrintCommand implements CommandInterface<null> {
+    private readonly consoleManager;
+    private readonly configLoader;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader);
+    run(args: any): Promise<ExitCodeEnum | number>;
+}

package/dist/types/commands/help-alias.command.d.ts

@@ -0,0 +1,17 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { HelpCommand } from "./help.command";
+/**
+ * Top-level alias for the framework-reserved `p:help` command. Injects the delegate
+ * directly via standard DI — `HelpCommand` is `@injectable()` and tsyringe resolves it
+ * recursively when this alias is constructed. The two share state via DI, not via a
+ * service-locator handle to the kernel container.
+ */
+export declare class HelpAliasCommand implements CommandInterface<null> {
+    private readonly delegate;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(delegate: HelpCommand);
+    run(args: any): Promise<ExitCodeEnum | number>;
+}

package/dist/types/commands/help.command.d.ts

@@ -1,10 +1,28 @@
+import { DependencyContainer } from "tsyringe";
 import { CommandInterface } from "../interfaces/command.interface";
 import { ConsoleManager } from "../managers/console.manager";
 import { ExitCodeEnum } from "../enums/exit-code.enum";
+/**
+ * Prints a usage banner plus a one-line summary for every registered command. The output is
+ * generated from the actual `CommandInterface[]` resolved from the current DI container, so
+ * newly registered (built-in or custom) commands show up automatically.
+ *
+ * The first column is sized to the longest command name in the set, so the second-column
+ * descriptions stay aligned even when commands have wildly different name lengths.
+ *
+ * **Lazy command resolution.** This command is itself `@tag(Command)`, so a constructor-time
+ * `@injectAll(ServiceDefinitionTagEnum.Command)` would create an infinite cycle: tsyringe
+ * tries to construct HelpCommand → must inject all Commands → must construct HelpCommand →
+ * recursion. We instead inject the current child container (registered by the kernel under
+ * `ServiceDefinitionTagEnum.CurrentChildContainer`) and call `resolveAll` from inside `run()`,
+ * by which point every Command-tagged class is fully constructed and cached.
+ */
 export declare class HelpCommand implements CommandInterface<null> {
     private readonly consoleManager;
+    private readonly container;
     optionsType: null;
     name: string;
-    constructor(consoleManager: ConsoleManager);
+    description: string;
+    constructor(consoleManager: ConsoleManager, container: DependencyContainer);
     run(args: any): Promise<ExitCodeEnum | number>;
 }

package/dist/types/commands/info-alias.command.d.ts

@@ -0,0 +1,15 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { InfoCommand } from "./info.command";
+/**
+ * Top-level alias for the framework-reserved `p:info` command. Injects the delegate
+ * directly via standard DI.
+ */
+export declare class InfoAliasCommand implements CommandInterface<null> {
+    private readonly delegate;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(delegate: InfoCommand);
+    run(args: any): Promise<ExitCodeEnum | number>;
+}

package/dist/types/commands/info.command.d.ts

@@ -0,0 +1,41 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ConsoleManager } from "../managers/console.manager";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { ConfigLoader } from "../config/config-loader";
+import { AppModuleLoader } from "../bootstrap/app-module-loader";
+/**
+ * Diagnostic command. Prints framework version, runtime environment, resolved config +
+ * AppModule locations, the recursively-resolved list of imported modules, and the list of
+ * loaded plugins. Designed for support tickets and "is my project picking up what I think
+ * it's picking up?" sanity checks.
+ *
+ * Does not boot a fresh kernel — it inspects what *would* be loaded by re-running the
+ * loader cascade, so it remains useful even when the AppModule is broken in a way that
+ * prevents `kernel.start()`.
+ */
+export declare class InfoCommand implements CommandInterface<null> {
+    private readonly consoleManager;
+    private readonly configLoader;
+    private readonly appModuleLoader;
+    optionsType: null;
+    name: string;
+    description: string;
+    /**
+     * Resolved at command construction time so `pristine info` reports the version of the cli
+     * that's actually running, not whatever happens to live in the user's project root. The
+     * package.json sits four levels up from dist/lib/cjs/commands/.
+     */
+    private readonly cliPackageJsonPath;
+    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader, appModuleLoader: AppModuleLoader);
+    run(args: any): Promise<ExitCodeEnum | number>;
+    private printRuntimeBanner;
+    private printConfigSection;
+    private printAppModuleSection;
+    private readCliVersion;
+    /**
+     * Walks the import tree, returning every module reachable from the root. Visits each
+     * module at most once via a keyname-keyed seen-set so circular imports don't loop.
+     * @private
+     */
+    private collectModules;
+}

package/dist/types/commands/init-alias.command.d.ts

@@ -0,0 +1,16 @@
+import { CommandInterface } from "../interfaces/command.interface";
+import { ExitCodeEnum } from "../enums/exit-code.enum";
+import { InitCommand } from "./init.command";
+import { InitCommandOptions } from "./init.command-options";
+/**
+ * Top-level alias for the framework-reserved `p:init` command. Injects the delegate
+ * directly via standard DI.
+ */
+export declare class InitAliasCommand implements CommandInterface<InitCommandOptions> {
+    private readonly delegate;
+    optionsType: typeof InitCommandOptions;
+    name: string;
+    description: string;
+    constructor(delegate: InitCommand);
+    run(args: InitCommandOptions): Promise<ExitCodeEnum | number>;
+}

package/dist/types/commands/init.command-options.d.ts

@@ -0,0 +1,22 @@
+import "reflect-metadata";
+/**
+ * Non-interactive flags for `pristine init`. In a TTY, the init command prompts the user for
+ * each missing value; in CI / non-TTY, every value must be supplied via these flags or the
+ * command exits with a clear "missing flag" error.
+ */
+export declare class InitCommandOptions {
+    "source-path"?: string;
+    "output-path"?: string;
+    tsconfig?: string;
+    format?: "esm" | "cjs" | "both";
+    /**
+     * When true, scaffold a starter `<sourcePath>` AppModule file if it doesn't exist.
+     * Default true. Pass `--no-scaffold` to skip.
+     */
+    scaffold?: boolean;
+    /**
+     * When true, add `pristine build`/`start`/`verify` scripts to package.json (only for
+     * scripts that don't already exist — never overwritten). Default true.
+     */
+    scripts?: boolean;
+}