toolcraft 0.0.89 → 0.0.91

package/dist/cli.compile-check.js

@@ -1,6 +1,6 @@
 import { S } from "toolcraft-schema";
 import { defineCommand, defineGroup } from "./index.js";
-import { runCLI } from "./cli.js";
+import { createCLICommandTreeSnapshot, renderErrorReport, runCLI } from "./cli.js";
 const ignoredCommand = defineCommand({
     name: "deploy",
     params: S.Object({
@@ -37,4 +37,19 @@ const ignoredServiceOptions = {
 };
 void runCLI(ignoredRoot, ignoredOptions);
 void runCLI([ignoredRoot], ignoredOptions);
+const ignoredSnapshot = createCLICommandTreeSnapshot(ignoredRoot, {
+    approvals: true,
+    casing: "kebab",
+    controls: ignoredOptions.controls,
+    presets: true,
+    version: ignoredOptions.version,
+});
+void ignoredSnapshot;
+const ignoredRenderedReport = renderErrorReport({
+    command: ignoredCommand,
+    env: {},
+    error: new Error("fixture"),
+    version: "1.0.0",
+});
+void ignoredRenderedReport;
 void ignoredServiceOptions;

package/dist/cli.d.ts

@@ -3,6 +3,8 @@ import { configureTheme } from "toolcraft-design";
 import type { Group, LogLevel, RuntimeLoggerInput } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
 import type { HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
+export { renderErrorReport } from "./error-report.js";
+export type { ErrorReportRenderContext, ErrorReportRenderResult } from "./error-report.js";
 export { configureTheme };
 type Casing = "kebab" | "snake";
 export interface CLIControls {
@@ -30,4 +32,59 @@ export interface RunCLIOptions<TServices extends object = Record<string, unknown
     presets?: boolean;
     errorReports?: ErrorReportsOption;
 }
+export interface CLICommandTreeSnapshotOption {
+    name: string;
+    flags: string[];
+    type: string;
+    required: boolean;
+    hidden: boolean;
+    description?: string;
+    default?: unknown;
+    positional?: boolean;
+    global?: boolean;
+    dynamic?: boolean;
+}
+export interface CLICommandTreeSnapshotCommand {
+    kind: "command";
+    name: string;
+    path: string[];
+    aliases: string[];
+    hidden: boolean;
+    default: boolean;
+    description?: string;
+    options: CLICommandTreeSnapshotOption[];
+}
+export interface CLICommandTreeSnapshotGroup {
+    kind: "group";
+    name: string;
+    path: string[];
+    aliases: string[];
+    hidden: false;
+    default: boolean;
+    description?: string;
+    children: CLICommandTreeSnapshotNode[];
+}
+export type CLICommandTreeSnapshotNode = CLICommandTreeSnapshotCommand | CLICommandTreeSnapshotGroup;
+export interface CLICommandTreeSnapshot {
+    schemaVersion: 1;
+    globalOptions: CLICommandTreeSnapshotOption[];
+    root: CLICommandTreeSnapshotGroup;
+}
+export interface CLICommandTreeSnapshotOptions {
+    approvals?: boolean;
+    argv?: readonly string[];
+    casing?: Casing;
+    controls?: CLIControls;
+    presets?: boolean;
+    version?: string;
+}
+/**
+ * Returns the resolved CLI command surface as deterministic plain data.
+ *
+ * Schema version 1 is independent of human-facing help layout. Nodes and options retain
+ * declaration order, paths exclude the root name, non-CLI nodes are omitted, hidden commands
+ * remain present, and Toolcraft-controlled global options are reported separately. A future
+ * incompatible shape change will increment `schemaVersion`.
+ */
+export declare function createCLICommandTreeSnapshot<TServices extends object>(roots: Group<TServices> | Group<TServices>[], options?: CLICommandTreeSnapshotOptions): Promise<CLICommandTreeSnapshot>;
 export declare function runCLI<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options?: RunCLIOptions<TServices>): Promise<void>;

package/dist/cli.js

@@ -16,6 +16,7 @@ import { renderSourceSnippet } from "./source-snippet.js";
 import { enableSourceMaps, formatDebugStack } from "./stack-trim.js";
 import { suggest } from "./suggest.js";
 import { throwValidationErrors } from "./validation-errors.js";
+export { renderErrorReport } from "./error-report.js";
 configureTheme({ brand: "blue", label: "Toolcraft" });
 export { configureTheme };
 const RESERVED_SERVICE_NAMES = new Set([
@@ -39,6 +40,29 @@ const optionalModulePaths = {
 function importOptionalModule(specifier) {
     return import(specifier);
 }
+/**
+ * Returns the resolved CLI command surface as deterministic plain data.
+ *
+ * Schema version 1 is independent of human-facing help layout. Nodes and options retain
+ * declaration order, paths exclude the root name, non-CLI nodes are omitted, hidden commands
+ * remain present, and Toolcraft-controlled global options are reported separately. A future
+ * incompatible shape change will increment `schemaVersion`.
+ */
+export async function createCLICommandTreeSnapshot(roots, options = {}) {
+    const argv = [...(options.argv ?? ["node", "toolcraft"])];
+    const normalizedRoot = normalizeRoots(roots, argv);
+    const root = options.approvals === true
+        ? (await importOptionalModule(optionalModulePaths.approvals)).mergeApprovalsGroup(normalizedRoot)
+        : normalizedRoot;
+    const controls = resolveCLIControls(options.controls);
+    const presetsEnabled = options.presets === true;
+    const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled, options.version !== undefined, controls);
+    return {
+        schemaVersion: 1,
+        globalOptions: createGlobalSnapshotOptions(presetsEnabled, options.version !== undefined, controls),
+        root: createSnapshotGroup(root, options.casing ?? "kebab", globalLongOptionFlags, [], false)
+    };
+}
 function inferProgramName(argv) {
     const entrypoint = argv[1];
     if (typeof entrypoint !== "string" || entrypoint.length === 0) {
@@ -1482,6 +1506,150 @@ function getToolcraftReservedChildNames(command) {
 function getNodeCommandNames(node) {
     return [node.name, ...node.aliases].filter((name) => name.length > 0);
 }
+function createGlobalSnapshotOptions(presetsEnabled, versionEnabled, controls) {
+    const options = [
+        {
+            name: "help",
+            flags: ["-h", "--help"],
+            type: "boolean",
+            required: false,
+            hidden: false,
+            description: "Display help for command."
+        }
+    ];
+    if (presetsEnabled) {
+        options.push({
+            name: "preset",
+            flags: ["--preset"],
+            type: "string",
+            required: false,
+            hidden: true,
+            description: "Load parameter defaults from a JSON file."
+        });
+    }
+    if (controls.yes) {
+        options.push({
+            name: "yes",
+            flags: ["--yes"],
+            type: "boolean",
+            required: false,
+            hidden: true,
+            description: "Accept defaults and skip prompts."
+        });
+    }
+    if (controls.output) {
+        options.push({
+            name: "output",
+            flags: ["--output"],
+            type: "enum",
+            required: false,
+            hidden: true,
+            description: "Output format."
+        });
+    }
+    if (controls.debug) {
+        options.push({
+            name: "debug",
+            flags: ["--debug"],
+            type: "enum",
+            required: false,
+            hidden: true,
+            description: "Print stack traces for unexpected errors."
+        });
+    }
+    if (controls.logLevel) {
+        options.push({
+            name: "logLevel",
+            flags: ["--log-level"],
+            type: "enum",
+            required: false,
+            hidden: true,
+            description: "Set runtime diagnostic log level."
+        });
+    }
+    if (controls.verbose) {
+        options.push({
+            name: "verbose",
+            flags: ["-v", "--verbose"],
+            type: "boolean",
+            required: false,
+            hidden: true,
+            description: "Print detailed runtime diagnostics."
+        });
+    }
+    if (versionEnabled) {
+        options.push({
+            name: "version",
+            flags: ["--version"],
+            type: "boolean",
+            required: false,
+            hidden: false,
+            description: "Output the version number."
+        });
+    }
+    return options;
+}
+function createSnapshotGroup(group, casing, globalLongOptionFlags, pathSegments, isDefault) {
+    const children = group.children
+        .filter((child) => isNodeVisibleInScope(child, "cli"))
+        .map((child) => createSnapshotNode(child, casing, globalLongOptionFlags, [...pathSegments, child.name], group.default === child));
+    return {
+        kind: "group",
+        name: group.name,
+        path: pathSegments,
+        aliases: [...group.aliases],
+        hidden: false,
+        default: isDefault,
+        ...(group.description === undefined ? {} : { description: group.description }),
+        children
+    };
+}
+function createSnapshotNode(node, casing, globalLongOptionFlags, pathSegments, isDefault) {
+    if (node.kind === "group") {
+        return createSnapshotGroup(node, casing, globalLongOptionFlags, pathSegments, isDefault);
+    }
+    const collected = collectFields(node.params, casing, globalLongOptionFlags);
+    const fields = assignPositionals(collected.fields, node.positional);
+    validateUniqueOptionFlags(fields, globalLongOptionFlags);
+    return {
+        kind: "command",
+        name: node.name,
+        path: pathSegments,
+        aliases: [...node.aliases],
+        hidden: node.hidden,
+        default: isDefault,
+        ...(node.description === undefined ? {} : { description: node.description }),
+        options: [
+            ...fields.map((field) => createFieldSnapshotOption(field, globalLongOptionFlags)),
+            ...collected.dynamicFields.flatMap((field) => createDynamicSnapshotOptions(field, casing))
+        ]
+    };
+}
+function createFieldSnapshotOption(field, globalLongOptionFlags) {
+    return {
+        name: field.displayPath,
+        flags: formatHelpFieldFlags(field, globalLongOptionFlags).split(", "),
+        type: formatJsonHelpSchemaType(field.schema),
+        required: field.requiredWhenActive,
+        hidden: false,
+        ...(field.description === undefined ? {} : { description: field.description }),
+        ...(field.hasDefault ? { default: field.defaultValue } : {}),
+        ...(field.positionalIndex === undefined ? {} : { positional: true }),
+        ...(field.global === true ? { global: true } : {})
+    };
+}
+function createDynamicSnapshotOptions(field, casing) {
+    return formatDynamicHelpFields(field, casing).map((row) => ({
+        name: field.displayPath,
+        flags: [row.flags],
+        type: describeDynamicFieldType(field),
+        required: field.requiredWhenActive,
+        hidden: false,
+        ...(field.description === undefined ? {} : { description: field.description }),
+        ...(field.hasDefault ? { default: field.defaultValue } : {}),
+        dynamic: true
+    }));
+}
 function addGlobalOptions(command, presetsEnabled, controls) {
     const options = [];
     if (presetsEnabled) {

package/dist/error-report.d.ts

@@ -18,6 +18,11 @@ export interface ErrorReportResult {
     absolutePath: string;
     displayPath: string;
 }
+export type ErrorReportRenderContext = Omit<ErrorReportContext, "errorReports" | "projectRoot">;
+export interface ErrorReportRenderResult {
+    content: string;
+    redactedKeys: string[];
+}
 interface HttpErrorLike {
     name: "HttpError";
     message: string;
@@ -35,5 +40,11 @@ interface HttpErrorLike {
     };
 }
 declare function hasHttpContext(error: unknown): error is HttpErrorLike;
+/**
+ * Renders the exact redacted content used by `writeErrorReport` without checking report enablement
+ * or writing to the filesystem. `redactedKeys` lists every environment variable declared by the
+ * command's secrets in declaration order, including variables that are currently unset.
+ */
+export declare function renderErrorReport(context: ErrorReportRenderContext): ErrorReportRenderResult;
 export declare function writeErrorReport(context: ErrorReportContext): Promise<ErrorReportResult | undefined>;
 export { hasHttpContext };

package/dist/error-report.js

@@ -410,6 +410,17 @@ function buildReport(context) {
     }
     return `${lines.join("\n")}\n`;
 }
+/**
+ * Renders the exact redacted content used by `writeErrorReport` without checking report enablement
+ * or writing to the filesystem. `redactedKeys` lists every environment variable declared by the
+ * command's secrets in declaration order, including variables that are currently unset.
+ */
+export function renderErrorReport(context) {
+    return {
+        content: buildReport(context),
+        redactedKeys: commandSecretEnvNames(context.command?.secrets)
+    };
+}
 export async function writeErrorReport(context) {
     const env = context.env ?? process.env;
     if (!reportsEnabled(context.errorReports, env) || isSkippedError(context.error)) {
@@ -423,7 +434,7 @@ export async function writeErrorReport(context) {
     if (reportDirMustStayWithinProject(context.errorReports)) {
         await assertReportDirWithinProject(projectRoot, reportDir);
     }
-    await writeFile(absolutePath, buildReport(context));
+    await writeFile(absolutePath, renderErrorReport(context).content);
     return {
         absolutePath,
         displayPath: relativeDisplayPath(projectRoot, absolutePath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.89",
+  "version": "0.0.91",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -56,7 +56,7 @@
     "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.89",
+    "toolcraft-schema": "0.0.91",
     "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",