@tiangong-lca/cli 0.1.1 → 0.1.2

package/dist/src/lib/lifecyclemodel-qa.d.ts

@@ -0,0 +1,206 @@
+import type { ValidationIssue } from './validation.js';
+type JsonObject = Record<string, unknown>;
+type ModelEntry = {
+    runName: string;
+    modelFiles: string[];
+    summaryPath: string;
+    connectionsPath: string;
+    processCatalogPath: string;
+    inputMode: 'run_dir' | 'rows_file';
+};
+type ModelFileReviewInfo = {
+    modelFile: string;
+    modelUuid: string;
+    modelVersion: string;
+    referenceProcessInternalId: string | null;
+    resultingProcessUuid: string | null;
+    processInstanceCount: number;
+    zeroMultiplicationFactorCount: number;
+};
+type LifecyclemodelValidationAggregate = {
+    ok: boolean | null;
+    reportPath: string | null;
+    modelReports: Map<string, LifecyclemodelModelValidationSummary>;
+};
+type LifecyclemodelModelValidationSummary = {
+    ok: boolean | null;
+    reportFile: string | null;
+    engineCount: number;
+    issues: ValidationIssue[];
+};
+type SeverityCounts = {
+    error: number;
+    warning: number;
+    info: number;
+};
+export type LifecyclemodelQaFinding = {
+    run_name: string;
+    model_file: string | null;
+    severity: 'error' | 'warning' | 'info';
+    rule_id: string;
+    source: 'validation' | 'qa';
+    message: string;
+    evidence: JsonObject;
+};
+export type LifecyclemodelQaModelSummary = {
+    run_name: string;
+    model_files: string[];
+    model_uuids: string[];
+    model_versions: string[];
+    reference_process_uuids: string[];
+    reference_process_internal_ids: string[];
+    resulting_process_uuids: string[];
+    summary_process_count: number | null;
+    process_instance_count: number;
+    summary_edge_count: number | null;
+    connection_count: number | null;
+    process_catalog_count: number | null;
+    multiplication_factor_count: number;
+    zero_multiplication_factor_count: number;
+    validation: {
+        available: boolean;
+        ok: boolean | null;
+        report_file: string | null;
+        engine_count: number;
+        issue_count: number;
+    };
+    artifacts: {
+        summary: string | null;
+        connections: string | null;
+        process_catalog: string | null;
+    };
+    finding_count: number;
+    severity_counts: SeverityCounts;
+};
+export type LifecyclemodelQaReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_local_lifecyclemodel_qa';
+    run_id: string;
+    run_root: string;
+    rows_file: string;
+    input_mode: 'run_dir' | 'rows_file';
+    out_dir: string;
+    logic_version: string;
+    model_count: number;
+    finding_count: number;
+    severity_counts: SeverityCounts;
+    validation: {
+        available: boolean;
+        ok: boolean | null;
+        report: string | null;
+    };
+    files: {
+        run_manifest: string;
+        invocation_index: string;
+        qa_input_summary: string | null;
+        validation_report: string | null;
+        model_summaries: string;
+        findings: string;
+        summary: string;
+        qa_zh: string;
+        qa_en: string;
+        timing: string;
+        report: string;
+    };
+    model_summaries: LifecyclemodelQaModelSummary[];
+    next_actions: string[];
+};
+export type RunLifecyclemodelQaOptions = {
+    runDir?: string;
+    rowsFile?: string;
+    outDir: string;
+    startTs?: string;
+    endTs?: string;
+    logicVersion?: string;
+    now?: () => Date;
+    cwd?: string;
+};
+export type LifecyclemodelQaLayout = {
+    runId: string;
+    runRoot: string;
+    rowsFile: string;
+    inputMode: 'run_dir' | 'rows_file';
+    outDir: string;
+    modelsDir: string;
+    reportsDir: string;
+    manifestsDir: string;
+    runManifestPath: string;
+    invocationIndexPath: string;
+    validationReportPath: string;
+    qaInputSummaryPath: string | null;
+    modelSummariesPath: string;
+    findingsPath: string;
+    summaryPath: string;
+    reviewZhPath: string;
+    reviewEnPath: string;
+    timingPath: string;
+    reportPath: string;
+};
+declare function sanitizeFileName(value: unknown): string;
+declare function buildLayout(options: {
+    runRoot: string;
+    outDir: string;
+    rowsFile?: string;
+    inputMode?: 'run_dir' | 'rows_file';
+}): LifecyclemodelQaLayout;
+declare function resolveLayout(options: RunLifecyclemodelQaOptions): LifecyclemodelQaLayout;
+declare function readInvocationIndex(layout: LifecyclemodelQaLayout): JsonObject;
+declare function discoverModelEntries(layout: LifecyclemodelQaLayout): ModelEntry[];
+declare function materializeRowsFile(layout: LifecyclemodelQaLayout): {
+    invocationIndex: JsonObject;
+    validationAggregate: LifecyclemodelValidationAggregate;
+    modelEntries: ModelEntry[];
+};
+declare function readValidationAggregate(layout: LifecyclemodelQaLayout): LifecyclemodelValidationAggregate;
+declare function readModelFileReviewInfo(filePath: string): ModelFileReviewInfo;
+declare function buildModelReview(entry: ModelEntry, validationAggregate: LifecyclemodelValidationAggregate): {
+    summary: LifecyclemodelQaModelSummary;
+    findings: LifecyclemodelQaFinding[];
+};
+declare function buildInvocationIndex(layout: LifecyclemodelQaLayout, invocationIndex: JsonObject, options: RunLifecyclemodelQaOptions, now: Date): JsonObject;
+declare function buildNextActions(layout: LifecyclemodelQaLayout, validationAggregate: LifecyclemodelValidationAggregate): string[];
+declare function renderZhReview(options: {
+    runId: string;
+    logicVersion: string;
+    runRoot: string;
+    rowsFile: string;
+    inputMode: 'run_dir' | 'rows_file';
+    modelSummaries: LifecyclemodelQaModelSummary[];
+    findings: LifecyclemodelQaFinding[];
+    validation: LifecyclemodelQaReport['validation'];
+}): string;
+declare function renderEnReview(options: {
+    runId: string;
+    logicVersion: string;
+    runRoot: string;
+    rowsFile: string;
+    inputMode: 'run_dir' | 'rows_file';
+    modelSummaries: LifecyclemodelQaModelSummary[];
+    findings: LifecyclemodelQaFinding[];
+    validation: LifecyclemodelQaReport['validation'];
+}): string;
+declare function renderTiming(options: {
+    runId: string;
+    startTs?: string;
+    endTs?: string;
+    modelCount: number;
+}): string;
+export declare function runLifecyclemodelQa(options: RunLifecyclemodelQaOptions): Promise<LifecyclemodelQaReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveLayout: typeof resolveLayout;
+    readInvocationIndex: typeof readInvocationIndex;
+    discoverModelEntries: typeof discoverModelEntries;
+    readValidationAggregate: typeof readValidationAggregate;
+    materializeRowsFile: typeof materializeRowsFile;
+    sanitizeFileName: typeof sanitizeFileName;
+    readModelFileReviewInfo: typeof readModelFileReviewInfo;
+    buildModelReview: typeof buildModelReview;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+    renderZhReview: typeof renderZhReview;
+    renderEnReview: typeof renderEnReview;
+    renderTiming: typeof renderTiming;
+};
+export {};

package/dist/src/lib/lifecyclemodel-resulting-process.d.ts

@@ -0,0 +1,204 @@
+import type { FetchLike } from './http.js';
+type JsonObject = Record<string, unknown>;
+export type ProjectionMode = 'primary-only' | 'all-subproducts';
+export type PublishIntent = 'dry_run' | 'prepare_only' | 'publish';
+export type LifecyclemodelResultingProcessRequest = {
+    source_model: {
+        id: string | null;
+        version: string | null;
+        name: string | null;
+        json_ordered_path: string | null;
+        json_ordered: JsonObject | null;
+    };
+    projection: {
+        mode: ProjectionMode;
+        process_id: string | null;
+        process_version: string | null;
+        metadata_overrides: JsonObject;
+        attach_graph_snapshot: boolean;
+        attach_graph_snapshot_uri: string | null;
+    };
+    process_sources: {
+        process_catalog_path: string | null;
+        run_dirs: string[];
+        process_json_dirs: string[];
+        process_json_files: string[];
+        allow_remote_lookup: boolean;
+    };
+    publish: {
+        intent: PublishIntent;
+        prepare_process_payloads: boolean;
+        prepare_relation_payloads: boolean;
+    };
+};
+export type LifecyclemodelResultingProcessReport = {
+    generated_at_utc: string;
+    request_path: string;
+    out_dir: string;
+    status: string;
+    projected_process_count: number;
+    relation_count: number;
+    source_model: {
+        id: string;
+        version: string;
+        name: string;
+        json_ordered_path: string | null;
+        reference_to_resulting_process_id: string | null;
+        reference_to_resulting_process_version: string | null;
+        reference_process_instance_id: string | null;
+    };
+    files: {
+        normalized_request: string;
+        source_model_normalized: string;
+        source_model_summary: string;
+        projection_report: string;
+        process_projection_bundle: string;
+    };
+};
+export type RunLifecyclemodelResultingProcessOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+};
+type RemoteProcessLookupContext = {
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+};
+type ProcessRecord = {
+    processUuid: string;
+    version: string;
+    raw: JsonObject;
+    sourceLabel: string;
+    sourcePath: string | null;
+    referenceExchangeInternalId: string;
+    referenceFlowUuid: string;
+    referenceDirection: string;
+    referenceAmount: number;
+    inputAmounts: Record<string, number>;
+    outputAmounts: Record<string, number>;
+};
+type ProcessInstance = {
+    instance_id: string;
+    process_id: string;
+    process_version: string;
+    label: string;
+    multiplication_factor: number;
+    reference_to_process: JsonObject;
+    raw: JsonObject;
+};
+type Edge = {
+    edge_id: string;
+    from: string;
+    to: string;
+    exchange_id: string | null;
+    flow_uuid: string | null;
+};
+declare function uniqueStrings(values: Array<string | null | undefined>): string[];
+declare function toFiniteNumber(value: unknown, fieldName: string): number;
+declare function normalizeNumericOutput(value: number): number;
+declare function toBoolean(value: unknown, defaultValue: boolean): boolean;
+export declare function normalizeLifecyclemodelResultingProcessRequest(input: unknown, options: {
+    requestPath: string;
+}): LifecyclemodelResultingProcessRequest;
+declare function resolveNameField(namePayload: unknown): string | null;
+declare function normalizedNameInfo(namePayload: unknown, fallbackText: string): JsonObject;
+declare function modelIdentifier(model: JsonObject, sourceModel: LifecyclemodelResultingProcessRequest['source_model']): {
+    id: string;
+    version: string;
+    name: string;
+};
+declare function extractProcessInstances(model: JsonObject): ProcessInstance[];
+declare function extractEdges(model: JsonObject): Edge[];
+declare function processReferencePairs(model: JsonObject): Array<{
+    process_id: string;
+    version: string;
+}>;
+declare function parseProcessRecord(payload: JsonObject, options: {
+    sourceLabel: string;
+    sourcePath: string | null;
+}): ProcessRecord;
+declare function autoDetectProcessCatalogPath(modelPath: string | null): string | null;
+declare function autoDetectProcessJsonDirs(modelPath: string | null): string[];
+declare function processSourceDirs(request: LifecyclemodelResultingProcessRequest): string[];
+declare function locateLocalProcessFile(processId: string, version: string, options: {
+    processDirs: string[];
+    processFiles: string[];
+}): string | null;
+declare function loadSourceModel(request: LifecyclemodelResultingProcessRequest): {
+    sourceModelJson: JsonObject;
+    modelPath: string | null;
+};
+declare function referenceToResultingProcess(model: JsonObject): {
+    id: string | null;
+    version: string | null;
+};
+declare function referenceProcessInstanceId(model: JsonObject): string | null;
+declare function chooseReferenceInstance(processInstances: ProcessInstance[], requestedInstanceId: string | null): ProcessInstance;
+declare function cloneExchangeWithAmount(exchange: JsonObject, amount: number, internalId: string, options: {
+    quantitativeReference: boolean;
+}): JsonObject;
+declare function buildResultingProcessPayload(options: {
+    sourceModelId: string;
+    sourceModelVersion: string;
+    sourceModelName: string;
+    sourceModelNameInfo: JsonObject;
+    processId: string;
+    processVersion: string;
+    role: 'primary';
+    projectionSignature: string;
+    processInstances: ProcessInstance[];
+    edges: Edge[];
+    processRecords: Record<string, ProcessRecord>;
+    referenceProcessInstanceId: string | null;
+    metadataOverrides: JsonObject;
+    attachGraphSnapshotUri: string | null;
+}): JsonObject;
+declare function buildProjectionBundle(options: {
+    request: LifecyclemodelResultingProcessRequest;
+    sourceModelJson: JsonObject;
+    modelPath: string | null;
+    remoteLookup?: RemoteProcessLookupContext;
+}): Promise<{
+    bundle: JsonObject;
+    report: JsonObject;
+    sourceModelSummary: {
+        id: string;
+        version: string;
+        name: string;
+        json_ordered_path: string | null;
+        reference_to_resulting_process_id: string | null;
+        reference_to_resulting_process_version: string | null;
+        reference_process_instance_id: string | null;
+        resolved_process_summary: JsonObject;
+    };
+}>;
+declare function defaultOutDir(requestPath: string, subject: string, now?: Date): string;
+export declare function runLifecyclemodelBuildResultingProcess(options: RunLifecyclemodelResultingProcessOptions): Promise<LifecyclemodelResultingProcessReport>;
+export declare const __testInternals: {
+    uniqueStrings: typeof uniqueStrings;
+    toFiniteNumber: typeof toFiniteNumber;
+    normalizeNumericOutput: typeof normalizeNumericOutput;
+    toBoolean: typeof toBoolean;
+    resolveNameField: typeof resolveNameField;
+    normalizedNameInfo: typeof normalizedNameInfo;
+    modelIdentifier: typeof modelIdentifier;
+    extractProcessInstances: typeof extractProcessInstances;
+    extractEdges: typeof extractEdges;
+    processReferencePairs: typeof processReferencePairs;
+    parseProcessRecord: typeof parseProcessRecord;
+    autoDetectProcessCatalogPath: typeof autoDetectProcessCatalogPath;
+    autoDetectProcessJsonDirs: typeof autoDetectProcessJsonDirs;
+    processSourceDirs: typeof processSourceDirs;
+    locateLocalProcessFile: typeof locateLocalProcessFile;
+    loadSourceModel: typeof loadSourceModel;
+    referenceToResultingProcess: typeof referenceToResultingProcess;
+    referenceProcessInstanceId: typeof referenceProcessInstanceId;
+    chooseReferenceInstance: typeof chooseReferenceInstance;
+    cloneExchangeWithAmount: typeof cloneExchangeWithAmount;
+    buildResultingProcessPayload: typeof buildResultingProcessPayload;
+    buildProjectionBundle: typeof buildProjectionBundle;
+    defaultOutDir: typeof defaultOutDir;
+};
+export {};

package/dist/src/lib/lifecyclemodel-save-draft-run.d.ts

@@ -0,0 +1,96 @@
+import type { FetchLike } from './http.js';
+import { type JsonObject } from './dataset-local.js';
+import { type LifecyclemodelBundleWriteResult, type LifecyclemodelPublishMetadata } from './lifecyclemodel-bundle-save.js';
+import { normalizeIssuePath, type SafeParseSchema, type SdkValidationFactory } from './tidas-sdk-validation.js';
+export type LifecyclemodelPayloadValidationIssue = {
+    path: string;
+    message: string;
+    code: string;
+};
+export type LifecyclemodelPayloadValidationResult = {
+    ok: true;
+    validator: string;
+    issue_count: 0;
+    issues: [];
+} | {
+    ok: false;
+    validator: string;
+    issue_count: number;
+    issues: LifecyclemodelPayloadValidationIssue[];
+};
+type LifecyclemodelSaveDraftCandidate = {
+    id: string | null;
+    version: string | null;
+    payload: JsonObject;
+    metadata: LifecyclemodelPublishMetadata | null;
+    validation?: LifecyclemodelPayloadValidationResult;
+    error?: {
+        message: string;
+    };
+};
+export type LifecyclemodelSaveDraftModelReport = {
+    id: string | null;
+    version: string | null;
+    status: 'prepared' | 'executed' | 'failed';
+    validation?: LifecyclemodelPayloadValidationResult;
+    execution?: LifecyclemodelBundleWriteResult;
+    error?: {
+        message: string;
+    };
+};
+export type LifecyclemodelSaveDraftReport = {
+    generated_at_utc: string;
+    input_path: string;
+    out_dir: string;
+    commit: boolean;
+    mode: 'dry_run' | 'commit';
+    status: 'completed' | 'completed_with_failures';
+    counts: {
+        selected: number;
+        prepared: number;
+        executed: number;
+        failed: number;
+    };
+    files: {
+        normalized_input: string;
+        selected_lifecyclemodels: string;
+        progress_jsonl: string;
+        failures_jsonl: string;
+        summary_json: string;
+    };
+    lifecyclemodels: LifecyclemodelSaveDraftModelReport[];
+};
+export type RunLifecyclemodelSaveDraftOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    commit?: boolean | null;
+    rawInput?: unknown;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    validateLifecyclemodelPayloadImpl?: (payload: JsonObject) => LifecyclemodelPayloadValidationResult;
+};
+declare function getLifecyclemodelSchema(sdk?: {
+    LifeCycleModelSchema?: unknown;
+}): SafeParseSchema;
+declare function getLifecyclemodelFactory(sdk?: {
+    createLifeCycleModel?: unknown;
+}): SdkValidationFactory | null;
+export declare function validateLifecyclemodelPayload(payload: JsonObject, schema?: SafeParseSchema, createEntity?: SdkValidationFactory | null): LifecyclemodelPayloadValidationResult;
+declare function summarizeValidation(result: LifecyclemodelPayloadValidationResult): string;
+declare function buildCandidate(row: JsonObject, payload: JsonObject, validate: (payload: JsonObject) => LifecyclemodelPayloadValidationResult): LifecyclemodelSaveDraftCandidate;
+declare function serializeError(error: unknown): {
+    message: string;
+};
+export declare function runLifecyclemodelSaveDraft(options: RunLifecyclemodelSaveDraftOptions): Promise<LifecyclemodelSaveDraftReport>;
+export declare const __testInternals: {
+    buildCandidate: typeof buildCandidate;
+    getLifecyclemodelFactory: typeof getLifecyclemodelFactory;
+    getLifecyclemodelSchema: typeof getLifecyclemodelSchema;
+    normalizeIssuePath: typeof normalizeIssuePath;
+    serializeError: typeof serializeError;
+    summarizeValidation: typeof summarizeValidation;
+    validateLifecyclemodelPayload: typeof validateLifecyclemodelPayload;
+};
+export {};

package/dist/src/lib/lifecyclemodel-validate-build.d.ts

@@ -0,0 +1,78 @@
+import { type RunValidationOptions, type ValidationRunReport } from './validation.js';
+type JsonObject = Record<string, unknown>;
+type ModelBundleEntry = {
+    runName: string;
+    inputDir: string;
+    modelFiles: string[];
+};
+export type LifecyclemodelValidateBuildLayout = {
+    runId: string;
+    runRoot: string;
+    modelsDir: string;
+    reportsDir: string;
+    modelReportsDir: string;
+    manifestsDir: string;
+    runManifestPath: string;
+    invocationIndexPath: string;
+    autoBuildReportPath: string;
+    reportPath: string;
+};
+export type LifecyclemodelValidateBuildModelReport = {
+    run_name: string;
+    input_dir: string;
+    model_files: string[];
+    report_file: string;
+    validation: ValidationRunReport;
+};
+export type LifecyclemodelValidateBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_lifecyclemodel_validate_build';
+    run_id: string;
+    run_root: string;
+    ok: boolean;
+    engine: string;
+    counts: {
+        models: number;
+        ok: number;
+        failed: number;
+    };
+    files: {
+        run_manifest: string;
+        invocation_index: string;
+        auto_build_report: string | null;
+        report: string;
+        model_reports_dir: string;
+    };
+    model_reports: LifecyclemodelValidateBuildModelReport[];
+    next_actions: string[];
+};
+export type RunLifecyclemodelValidateBuildOptions = {
+    runDir: string;
+    engine?: string;
+    now?: Date;
+    cwd?: string;
+};
+export type LifecyclemodelValidateBuildDeps = {
+    runValidationImpl?: (options: RunValidationOptions) => Promise<ValidationRunReport>;
+};
+declare function buildLayout(runRoot: string): LifecyclemodelValidateBuildLayout;
+declare function resolveLayout(options: RunLifecyclemodelValidateBuildOptions): LifecyclemodelValidateBuildLayout;
+declare function readInvocationIndex(layout: LifecyclemodelValidateBuildLayout): JsonObject;
+declare function discoverModelEntries(layout: LifecyclemodelValidateBuildLayout): ModelBundleEntry[];
+declare function buildInvocationIndex(layout: LifecyclemodelValidateBuildLayout, invocationIndex: JsonObject, options: RunLifecyclemodelValidateBuildOptions, now: Date): JsonObject;
+declare function buildNextActions(layout: LifecyclemodelValidateBuildLayout): string[];
+declare function resolveValidationImpl(deps: LifecyclemodelValidateBuildDeps): (options: RunValidationOptions) => Promise<ValidationRunReport>;
+declare function resolveReportEngine(modelReports: LifecyclemodelValidateBuildModelReport[], requestedEngine?: string): string;
+export declare function runLifecyclemodelValidateBuild(options: RunLifecyclemodelValidateBuildOptions, deps?: LifecyclemodelValidateBuildDeps): Promise<LifecyclemodelValidateBuildReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveLayout: typeof resolveLayout;
+    readInvocationIndex: typeof readInvocationIndex;
+    discoverModelEntries: typeof discoverModelEntries;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+    resolveValidationImpl: typeof resolveValidationImpl;
+    resolveReportEngine: typeof resolveReportEngine;
+};
+export {};

package/dist/src/lib/llm.d.ts

@@ -0,0 +1,51 @@
+import type { EnvSpec } from './env.js';
+import type { FetchLike } from './http.js';
+export declare const LLM_ENV_KEYS: {
+    readonly baseUrl: 'TIANGONG_LCA_REVIEW_LLM_BASE_URL';
+    readonly apiKey: 'TIANGONG_LCA_REVIEW_LLM_API_KEY';
+    readonly model: 'TIANGONG_LCA_REVIEW_LLM_MODEL';
+};
+export declare const LLM_ENV_SPECS: EnvSpec[];
+export type LlmRuntimeEnv = {
+    baseUrl: string | null;
+    apiKey: string | null;
+    model: string | null;
+};
+export type LlmUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+};
+export type LlmInvocationInput = {
+    prompt: string;
+    context?: unknown;
+    responseFormat?: unknown;
+    text?: Record<string, unknown>;
+};
+export type LlmInvocationResult = {
+    output: string;
+    usage: LlmUsage | null;
+    cacheHit: boolean;
+    promptHash: string;
+};
+export type InvokeLlmOptions = {
+    env: LlmRuntimeEnv;
+    input: LlmInvocationInput;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxAttempts?: number;
+    sleep?: (ms: number) => Promise<void>;
+    retryDelayMs?: number;
+    cacheDir?: string | null;
+    tracePath?: string | null;
+    runId?: string | null;
+    module?: string;
+    stage?: string;
+    now?: () => Date;
+};
+export declare function extractLlmOutput(payload: unknown): string;
+export declare function extractLlmUsage(payload: unknown): LlmUsage | null;
+export declare function readLlmRuntimeEnv(env: NodeJS.ProcessEnv): LlmRuntimeEnv;
+export declare function invokeLlm(options: InvokeLlmOptions): Promise<LlmInvocationResult>;

package/dist/src/lib/package-version.d.ts

@@ -0,0 +1,3 @@
+type PackageVersionReader = (url: URL) => string;
+export declare function loadCliPackageVersion(importMetaUrl?: string, readText?: PackageVersionReader): string;
+export {};