@pristine-ts/cli 2.0.6 → 2.0.16

package/dist/lib/esm/types/start-repl-event-response.type.js

@@ -0,0 +1,9 @@
+import { EventResponse } from "@pristine-ts/core";
+/**
+ * The response shape produced by `ReplStartEventHandler` when the interactive session
+ * ends (`/exit` or EOF). Carries the exit code the bin should pass to `process.exit`,
+ * surfaced through `ReplStartEventMapper.reverseMap`.
+ */
+export class StartReplEventResponse extends EventResponse {
+}
+//# sourceMappingURL=start-repl-event-response.type.js.map

package/dist/lib/esm/types/start-repl-event-response.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-repl-event-response.type.js","sourceRoot":"","sources":["../../../../src/types/start-repl-event-response.type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAIhD;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,aAAuD;CAClG"}

package/dist/lib/esm/types/types.js

@@ -1,3 +1,4 @@
 export * from "./command-event.type";
 export * from "./command-event-response.type";
+export * from "./start-repl-event-response.type";
 //# sourceMappingURL=types.js.map

package/dist/lib/esm/types/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC"}

package/dist/lib/esm/utils/boolean-answer-parser.js

@@ -0,0 +1,21 @@
+/**
+ * Interprets a free-text answer as a boolean the way traditional CLIs do — accepting
+ * `y`/`yes`/`true`/`1` and `n`/`no`/`false`/`0` (case-insensitive, surrounding whitespace
+ * ignored). Returns `undefined` for anything unrecognized so callers can re-ask.
+ *
+ * Shared by `CliPrompt.confirm` (yes/no prompts) and `CommandParameterPrompter` (typed
+ * boolean parameters) so both accept exactly the same set of answers.
+ */
+export class BooleanAnswerParser {
+    static parse(raw) {
+        const normalized = raw.trim().toLowerCase();
+        if (normalized === "y" || normalized === "yes" || normalized === "true" || normalized === "1") {
+            return true;
+        }
+        if (normalized === "n" || normalized === "no" || normalized === "false" || normalized === "0") {
+            return false;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=boolean-answer-parser.js.map

package/dist/lib/esm/utils/boolean-answer-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-answer-parser.js","sourceRoot":"","sources":["../../../../src/utils/boolean-answer-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,mBAAmB;IAC9B,MAAM,CAAC,KAAK,CAAC,GAAW;QACtB,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC5C,IAAI,UAAU,KAAK,GAAG,IAAI,UAAU,KAAK,KAAK,IAAI,UAAU,KAAK,MAAM,IAAI,UAAU,KAAK,GAAG,EAAE,CAAC;YAC9F,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,UAAU,KAAK,GAAG,IAAI,UAAU,KAAK,IAAI,IAAI,UAAU,KAAK,OAAO,IAAI,UAAU,KAAK,GAAG,EAAE,CAAC;YAC9F,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/dist/lib/esm/utils/pristine-argv.js

@@ -0,0 +1,50 @@
+import * as path from "path";
+/**
+ * Parses an argv array — typically `process.argv` — to locate the pristine bin and
+ * extract the user-typed arguments that follow it.
+ *
+ * Why scan rather than positional-index: argv shape is runtime-dependent. Node and Bun
+ * happen to put `[executable, scriptPath, ...userArgs]` today, but a different runtime
+ * (or a launcher that prepends flags before the script) can violate that. Locating the
+ * bin by name — an element whose basename (stripped of any extension like `.cjs` /
+ * `.js` / `.mjs`) is `pristine` — is robust across:
+ *
+ *   - global installs (`pristine repl` → argv contains `/usr/local/.../pristine.cjs`)
+ *   - local installs (`./node_modules/.bin/pristine`)
+ *   - `npx pristine`
+ *   - direct `node dist/bin/pristine.cjs`
+ *   - alternative runtimes that may shape argv differently
+ *   - the synthetic argv the REPL handler builds for each typed line
+ *
+ * Stateless after construction; instantiate per parse.
+ */
+export class PristineArgv {
+    constructor(rawArgv) {
+        const binIndex = rawArgv.findIndex(arg => PristineArgv.isPristineBin(arg));
+        if (binIndex === -1) {
+            this.scriptPath = "";
+            this.userArgs = [];
+            return;
+        }
+        const scriptPath = rawArgv[binIndex];
+        this.scriptPath = typeof scriptPath === "string" ? scriptPath : "";
+        this.userArgs = rawArgv
+            .slice(binIndex + 1)
+            .filter((arg) => typeof arg === "string");
+    }
+    /**
+     * True when the argv was recognizable as a pristine invocation (the bin token was
+     * located). Mappers short-circuit `supportsMapping` on this.
+     */
+    get isValid() {
+        return this.scriptPath !== "";
+    }
+    static isPristineBin(arg) {
+        if (typeof arg !== "string") {
+            return false;
+        }
+        return path.basename(arg, path.extname(arg)) === PristineArgv.BIN_NAME;
+    }
+}
+PristineArgv.BIN_NAME = "pristine";
+//# sourceMappingURL=pristine-argv.js.map

package/dist/lib/esm/utils/pristine-argv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pristine-argv.js","sourceRoot":"","sources":["../../../../src/utils/pristine-argv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,YAAY;IASvB,YAAY,OAA2B;QACrC,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3E,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;YACrB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,CAAC,UAAU,GAAG,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;QACnE,IAAI,CAAC,QAAQ,GAAG,OAAO;aACpB,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC;aACnB,MAAM,CAAC,CAAC,GAAG,EAAiB,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACH,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,KAAK,EAAE,CAAC;IAChC,CAAC;IAEO,MAAM,CAAC,aAAa,CAAC,GAAY;QACvC,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,CAAC,QAAQ,CAAC;IACzE,CAAC;;AAnCuB,qBAAQ,GAAG,UAAU,CAAC"}

package/dist/lib/esm/utils/terminal-key-decoder.js

@@ -0,0 +1,67 @@
+import { TerminalKeyName } from "../enums/terminal-key-name.enum";
+/**
+ * Translates the raw bytes Node delivers from a raw-mode stdin into structured
+ * {@link TerminalKey}s. Pure and static so it can be unit-tested without a real TTY.
+ *
+ * A single `data` chunk can carry more than one keystroke (notably a paste, or fast
+ * typing), so this returns an array. Control and escape sequences are recognized as one
+ * key each; a run of printable characters is split into one `Character` key per character
+ * so callers (masked input, menus) can echo and handle them uniformly.
+ */
+export class TerminalKeyDecoder {
+    /**
+     * Decodes a raw stdin chunk into the keys it represents.
+     *
+     *   - A recognized control byte / escape sequence that spans the whole chunk → one key.
+     *   - An unrecognized escape sequence (starts with ESC) → a single `Other` key, rather
+     *     than splitting it into bogus printable characters.
+     *   - Anything else → one key per character, with non-printable control bytes mapped to
+     *     `Other` so they're ignored rather than echoed.
+     */
+    static decode(data) {
+        const whole = TerminalKeyDecoder.decodeControl(data);
+        if (whole !== undefined) {
+            return [whole];
+        }
+        if (data.charCodeAt(0) === 0x1b) {
+            return [{ name: TerminalKeyName.Other, sequence: data }];
+        }
+        const keys = [];
+        for (const character of data) {
+            const control = TerminalKeyDecoder.decodeControl(character);
+            if (control !== undefined) {
+                keys.push(control);
+            }
+            else if (character.charCodeAt(0) < 0x20) {
+                keys.push({ name: TerminalKeyName.Other, sequence: character });
+            }
+            else {
+                keys.push({ name: TerminalKeyName.Character, sequence: character });
+            }
+        }
+        return keys;
+    }
+    /**
+     * Maps a single recognized control byte or escape sequence to its key, or `undefined`
+     * when the input isn't one we handle.
+     * @private
+     */
+    static decodeControl(sequence) {
+        switch (sequence) {
+            case "\x1b[A":
+                return { name: TerminalKeyName.Up, sequence };
+            case "\x1b[B":
+                return { name: TerminalKeyName.Down, sequence };
+            case "\r":
+            case "\n":
+                return { name: TerminalKeyName.Enter, sequence };
+            case "\x7f":
+            case "\b":
+                return { name: TerminalKeyName.Backspace, sequence };
+            case "\x03":
+                return { name: TerminalKeyName.CtrlC, sequence };
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=terminal-key-decoder.js.map

package/dist/lib/esm/utils/terminal-key-decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-key-decoder.js","sourceRoot":"","sources":["../../../../src/utils/terminal-key-decoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAM,CAAC,IAAY;QACxB,MAAM,KAAK,GAAG,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,EAAC,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,IAAI,GAAkB,EAAE,CAAC;QAC/B,KAAK,MAAM,SAAS,IAAI,IAAI,EAAE,CAAC;YAC7B,MAAM,OAAO,GAAG,kBAAkB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YAC5D,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,CAAC;iBAAM,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC;gBAC1C,IAAI,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAC,CAAC,CAAC;YAChE,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAC,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACK,MAAM,CAAC,aAAa,CAAC,QAAgB;QAC3C,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,QAAQ;gBACX,OAAO,EAAC,IAAI,EAAE,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAC,CAAC;YAC9C,KAAK,QAAQ;gBACX,OAAO,EAAC,IAAI,EAAE,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAC,CAAC;YAChD,KAAK,IAAI,CAAC;YACV,KAAK,IAAI;gBACP,OAAO,EAAC,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAC,CAAC;YACjD,KAAK,MAAM,CAAC;YACZ,KAAK,IAAI;gBACP,OAAO,EAAC,IAAI,EAAE,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAC,CAAC;YACrD,KAAK,MAAM;gBACT,OAAO,EAAC,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAC,CAAC;QACnD,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

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

@@ -0,0 +1,15 @@
+/**
+ * Persists the user's selection from the disambiguation prompt so subsequent invocations of
+ * `pristine` in the same project skip the prompt. Stale entries (target file deleted since
+ * the cache was written) are auto-cleaned on read.
+ *
+ * Best-effort throughout — failures to read or write the cache file are swallowed because
+ * the cache is a UX optimization, not correctness-critical.
+ */
+export declare class AppModuleCache {
+    private readonly cacheDirName;
+    private readonly cacheFileName;
+    read(projectRoot: string): string | undefined;
+    write(projectRoot: string, absolutePath: string): void;
+    private cachePath;
+}

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

@@ -0,0 +1,30 @@
+import { AppModuleDiscoveryCandidate } from "./app-module-discovery-candidate";
+/**
+ * Scans well-known directories for files that look like AppModule definitions. Non-recursive
+ * (each search root is scanned at depth 1 only) so it stays fast on large repos and predictable
+ * when users have many nested module files.
+ *
+ * A file is a candidate when:
+ *   - its filename matches `*.module.{js,mjs,cjs}` (and is not a test/spec file), AND
+ *   - either the filename literally matches `app.module.{js,mjs,cjs}` (highest confidence,
+ *     scored 0), OR the file's exports include a symbol named `AppModule` (scored 10).
+ */
+export declare class AppModuleDiscoverer {
+    /**
+     * Search roots scanned for candidates, relative to the project root. Order is intentional:
+     * compiled output first (most likely runtime entry), then build/, then the project root
+     * itself for trivial single-file demos.
+     */
+    private readonly searchRoots;
+    private readonly moduleFileRegex;
+    private readonly appModuleNameRegex;
+    discover(projectRoot: string): Promise<AppModuleDiscoveryCandidate[]>;
+    /**
+     * Synchronous probe: does this file's exports include an `AppModule` symbol? Uses
+     * `require()` rather than dynamic `import()` because (a) we only accept `.js/.mjs/.cjs`
+     * whose CJS variants load synchronously, and (b) discarded probes shouldn't hold open
+     * `import()` promises.
+     * @private
+     */
+    private exportsAppModule;
+}

package/dist/types/bootstrap/app-module-discovery-candidate.d.ts

@@ -0,0 +1,18 @@
+import { AppModuleDiscoveryReasonEnum } from "./app-module-discovery-reason.enum";
+/**
+ * A plausible AppModule found by the convention-based scan. Lower `score` beats higher;
+ * ties are ambiguous and trigger the disambiguation prompt.
+ */
+export declare class AppModuleDiscoveryCandidate {
+    readonly absolutePath: string;
+    /** Path relative to the project root. Used purely for human-facing display. */
+    readonly displayPath: string;
+    /** Lower = better. Files literally named `app.module.*` get 0; AppModule-exporting `*.module.*` files get 10. */
+    readonly score: number;
+    readonly reason: AppModuleDiscoveryReasonEnum;
+    constructor(absolutePath: string, 
+    /** Path relative to the project root. Used purely for human-facing display. */
+    displayPath: string, 
+    /** Lower = better. Files literally named `app.module.*` get 0; AppModule-exporting `*.module.*` files get 10. */
+    score: number, reason: AppModuleDiscoveryReasonEnum);
+}

package/dist/types/bootstrap/app-module-discovery-reason.enum.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Why a candidate file was considered a possible AppModule. Used by the disambiguation prompt
+ * so the user sees "(matches app.module.*)" vs "(exports AppModule)" alongside each option.
+ */
+export declare enum AppModuleDiscoveryReasonEnum {
+    /** The filename matches `app.module.{js,mjs,cjs}`. Highest confidence. */
+    Named = "named",
+    /** The filename is `*.module.{js,mjs,cjs}` and the file's exports include an `AppModule` symbol. */
+    Exports = "exports"
+}

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

@@ -0,0 +1,20 @@
+import { AppModuleDiscoveryCandidate } from "./app-module-discovery-candidate";
+import { DynamicImporter } from "./dynamic-importer";
+/**
+ * TTY disambiguation for the AppModule discovery cascade. When multiple equally-ranked
+ * candidates exist and stdin/stdout are both connected to a real terminal, ask the user
+ * to pick one. When non-interactive (CI, Docker, redirected stdin), the caller should
+ * fall back to throwing an actionable error rather than guessing.
+ *
+ * `@inquirer/prompts` is dynamic-imported through `DynamicImporter` so the prompt UI
+ * dependency only loads when actually prompting — keeps non-interactive startup fast and
+ * avoids paying for inquirer's TTY-detection overhead on every invocation.
+ */
+export declare class AppModulePrompt {
+    private readonly dynamicImporter;
+    private readonly cancelLabel;
+    constructor(dynamicImporter: DynamicImporter);
+    isInteractive(): boolean;
+    prompt(candidates: AppModuleDiscoveryCandidate[]): Promise<string | undefined>;
+    private reasonLabel;
+}

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

@@ -4,7 +4,7 @@
  * 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
+ * of the build pipeline's dependency graph (LogHandler, ShellManager, CliOutput, 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.
  *

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

@@ -1,5 +1,5 @@
 import { BuildManifestStalenessEnum } from "./build-manifest-staleness.enum";
-import { DynamicImporter } from "./dynamic-importer";
+import { CliPrompt } from "../managers/cli-prompt.manager";
 /**
  * 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
@@ -10,9 +10,9 @@ import { DynamicImporter } from "./dynamic-importer";
  * this class stays small and testable.
  */
 export declare class BuildStalenessPrompt {
-    private readonly dynamicImporter;
+    private readonly cliPrompt;
     private readonly promptMessage;
-    constructor(dynamicImporter: DynamicImporter);
+    constructor(cliPrompt: CliPrompt);
     isInteractive(): boolean;
     /**
      * Renders a one-line explanation of why the manifest is stale. Used by both the prompt

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

@@ -1,4 +1,4 @@
-import { DynamicImporter } from "./dynamic-importer";
+import { CliPrompt } from "../managers/cli-prompt.manager";
 /**
  * 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
@@ -13,8 +13,8 @@ export interface InitAnswers {
     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).
+ * Interactive Q&A for `pristine init`. Prompts through {@link CliPrompt}, the CLI's native
+ * (no third-party dependency) terminal-prompt manager.
  *
  * 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 —
@@ -22,12 +22,12 @@ export interface InitAnswers {
  * prompt.
  */
 export declare class InitPrompt {
-    private readonly dynamicImporter;
+    private readonly cliPrompt;
     private readonly defaultSourcePath;
     private readonly defaultOutputPath;
     private readonly defaultTsconfig;
     private readonly defaultFormat;
-    constructor(dynamicImporter: DynamicImporter);
+    constructor(cliPrompt: CliPrompt);
     isInteractive(): boolean;
     askSourcePath(current: string | undefined): Promise<string>;
     askOutputPath(current: string | undefined): Promise<string>;

package/dist/types/cli.configuration-keys.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Typed configuration keys for `@pristine-ts/cli`. Use these constants with `@injectConfig`
+ * for autocomplete + rename safety, instead of typing the parameter name as a string.
+ *
+ * ```ts
+ * import {injectConfig} from "@pristine-ts/common";
+ * import {CliConfigurationKeys} from "@pristine-ts/cli";
+ *
+ * constructor(@injectConfig(CliConfigurationKeys.InteractiveParameters) enabled: boolean) {}
+ * ```
+ */
+export declare const CliConfigurationKeys: {
+    /**
+     * Whether the CLI may interactively ask for missing command parameters that declare a
+     * `question` (via `@commandParameter`). Defaults to `true`; set it to `false` to disable
+     * all such prompting (e.g. in CI). Prompting is also skipped automatically whenever the
+     * input is not an interactive terminal, regardless of this value.
+     */
+    readonly InteractiveParameters: "pristine.cli.interactiveParameters";
+};
+/**
+ * The expected runtime types for each configuration value defined by `@pristine-ts/cli`. The
+ * `@pristine-ts/eslint-plugin` rule `inject-config-type-match` reads the merged map to
+ * enforce parameter types on `@injectConfig` calls.
+ */
+export interface CliConfigurationValueMap {
+    "pristine.cli.interactiveParameters": boolean;
+}
+declare module "@pristine-ts/common" {
+    interface PristineConfigurationValueMap extends CliConfigurationValueMap {
+    }
+}

package/dist/types/cli.d.ts

@@ -47,11 +47,15 @@ export declare class Cli {
      */
     private readEnvironmentFromConfigFile;
     /**
-     * Builds a synthetic outer AppModule that imports both the user's AppModule and CliModule.
+     * Builds a synthetic outer AppModule that imports the user's AppModule plus `CliModule`
+     * — so the CLI's own commands are always registered when the bin is the entry point.
+     * `CliModule` itself imports `ObservabilityModule`, so the logs/traces store travels
+     * along without being named here.
+     *
      * The wrap is unconditional — the kernel dedupes module imports by keyname, so adding
-     * CliModule on top of a graph that already contains it is a no-op rather than an error
-     * or duplicate registration. Cheaper than walking the user's import tree to detect the
-     * already-present case.
+     * `CliModule` on top of a graph that already contains it is a no-op rather than an
+     * error or duplicate registration. Cheaper than walking the user's import tree to
+     * detect the already-present case.
      */
     private wrapWithCliModule;
     /**

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

@@ -1,7 +1,10 @@
 import { ModuleInterface } from "@pristine-ts/common";
 export * from "./bootstrap/bootstrap";
+export * from "./cli.configuration-keys";
 export * from "./commands/commands";
 export * from "./config/config";
+export * from "./decorators/decorators";
+export * from "./enums/enums";
 export * from "./errors/errors";
 export * from "./event-handlers/event-handlers";
 export * from "./event-payloads/event-payloads";
@@ -10,6 +13,7 @@ export * from "./managers/managers";
 export * from "./mappers/mappers";
 export * from "./options/options";
 export * from "./reporters/cli-error.reporter";
+export * from "./services/services";
 export * from "./types/types";
 export { Cli } from "./cli";
 export declare const CliModule: ModuleInterface;

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

@@ -1,6 +1,6 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
 import { ShellManager } from "../managers/shell.manager";
 import { ConfigLoader } from "../config/config-loader";
 import { BuildManifestWriter } from "../bootstrap/build-manifest-writer";
@@ -24,7 +24,7 @@ import { BuildManifestWriter } from "../bootstrap/build-manifest-writer";
  *   - clean:    false           (set true to wipe outDir before building)
  */
 export declare class BuildCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly shellManager;
     private readonly configLoader;
     private readonly buildManifestWriter;
@@ -33,7 +33,7 @@ export declare class BuildCommand implements CommandInterface<null> {
     description: string;
     private readonly defaultTsconfig;
     private readonly defaultFormat;
-    constructor(consoleManager: ConsoleManager, shellManager: ShellManager, configLoader: ConfigLoader, buildManifestWriter: BuildManifestWriter);
+    constructor(logHandler: LogHandlerInterface, shellManager: ShellManager, configLoader: ConfigLoader, buildManifestWriter: BuildManifestWriter);
     run(args: any): Promise<ExitCode | number>;
     private writeManifestIfConfigured;
     /**

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

@@ -10,8 +10,14 @@ export * from "./init.command";
 export * from "./init.command-options";
 export * from "./list-alias.command";
 export * from "./list.command";
+export * from "./logs-alias.command";
+export * from "./logs.command";
+export * from "./requests-alias.command";
+export * from "./requests.command";
 export * from "./start-alias.command";
 export * from "./start.command";
 export * from "./start.command-options";
+export * from "./trace-alias.command";
+export * from "./trace.command";
 export * from "./verify-alias.command";
 export * from "./verify.command";

package/dist/types/commands/config-init.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";
+/**
+ * Generates a starter `pristine.config.ts` in the current directory. If the consumer's
+ * `package.json` already declares `pristine.appModule.path` or `pristine.appModule.cjsPath`,
+ * the value is migrated into the new config and the user is told to remove the old field.
+ */
+export declare class ConfigInitCommand implements CommandInterface<null> {
+    private readonly consoleManager;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(consoleManager: ConsoleManager);
+    run(args: any): Promise<ExitCodeEnum | number>;
+    private detectExistingAppModulePath;
+    private renderConfigTemplate;
+}

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

@@ -1,18 +1,23 @@
 import { ExitCode } from "@pristine-ts/common";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 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?"
+ *
+ * This is a report command: its entire output is the report. It goes through `CliOutput`
+ * exclusively (not `LogHandler`) so the dump pipes/redirects cleanly — `pristine
+ * p:config:print > config.json` must produce a usable file, with no severity gating, no
+ * per-line timestamp/icon decoration, and no fan-out to file/Sentry transports.
  */
 export declare class ConfigPrintCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly configLoader;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader);
+    constructor(cliOutput: CliOutput, configLoader: ConfigLoader);
     run(args: any): Promise<ExitCode | number>;
 }

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

@@ -1,7 +1,7 @@
 import { DependencyContainer } from "tsyringe";
 import { ExitCode } from "@pristine-ts/common";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 /**
  * 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
@@ -18,11 +18,11 @@ import { ConsoleManager } from "../managers/console.manager";
  * by which point every Command-tagged class is fully constructed and cached.
  */
 export declare class HelpCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly container;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, container: DependencyContainer);
+    constructor(cliOutput: CliOutput, container: DependencyContainer);
     run(args: any): Promise<ExitCode | number>;
 }

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

@@ -1,6 +1,7 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 import { ConfigLoader } from "../config/config-loader";
 import { AppModuleLoader } from "../bootstrap/app-module-loader";
 /**
@@ -14,7 +15,8 @@ import { AppModuleLoader } from "../bootstrap/app-module-loader";
  * prevents `kernel.start()`.
  */
 export declare class InfoCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly logHandler;
+    private readonly cliOutput;
     private readonly configLoader;
     private readonly appModuleLoader;
     optionsType: null;
@@ -26,7 +28,7 @@ export declare class InfoCommand implements CommandInterface<null> {
      * package.json sits four levels up from dist/lib/cjs/commands/.
      */
     private readonly cliPackageJsonPath;
-    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader, appModuleLoader: AppModuleLoader);
+    constructor(logHandler: LogHandlerInterface, cliOutput: CliOutput, configLoader: ConfigLoader, appModuleLoader: AppModuleLoader);
     run(args: any): Promise<ExitCode | number>;
     private printRuntimeBanner;
     private printConfigSection;

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

@@ -1,6 +1,6 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
 import { InitCommandOptions } from "./init.command-options";
 import { InitPrompt } from "../bootstrap/init-prompt";
 /**
@@ -19,14 +19,14 @@ import { InitPrompt } from "../bootstrap/init-prompt";
  * Refuses to overwrite an existing `pristine.config.ts` so re-running init is safe.
  */
 export declare class InitCommand implements CommandInterface<InitCommandOptions> {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly initPrompt;
     optionsType: typeof InitCommandOptions;
     name: string;
     description: string;
     private readonly configFileName;
     private readonly gitignoreEntry;
-    constructor(consoleManager: ConsoleManager, initPrompt: InitPrompt);
+    constructor(logHandler: LogHandlerInterface, initPrompt: InitPrompt);
     run(args: InitCommandOptions): Promise<ExitCode | number>;
     /**
      * Fills in answers from CLI flags first, then prompts (in TTY) for whatever's missing.

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

@@ -1,18 +1,18 @@
 import { ExitCode } from "@pristine-ts/common";
 import { DependencyContainer } from "tsyringe";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 /**
  * Lists every registered command's name. Like `HelpCommand`, this resolves the command set
  * lazily inside `run()` via the injected child container to avoid the self-referential cycle
  * that constructor-time `@injectAll(Command)` would create — see `HelpCommand` for details.
  */
 export declare class ListCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly container;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, container: DependencyContainer);
+    constructor(cliOutput: CliOutput, container: DependencyContainer);
     run(args: any): Promise<ExitCode | number>;
 }

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

@@ -0,0 +1,14 @@
+import { ExitCode } from "@pristine-ts/common";
+import { CommandInterface } from "../interfaces/command.interface";
+import { LogsCommand } from "./logs.command";
+/**
+ * Top-level alias for `p:logs`.
+ */
+export declare class LogsAliasCommand implements CommandInterface<null> {
+    private readonly delegate;
+    optionsType: null;
+    name: string;
+    description: string;
+    constructor(delegate: LogsCommand);
+    run(args: any): Promise<ExitCode | number>;
+}