@tiangong-lca/cli 0.1.1 → 0.1.2

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

@@ -0,0 +1,91 @@
+import { type JsonObject } from './dataset-local.js';
+export type LifecyclemodelGraphFormat = 'json' | 'dot' | 'svg' | 'all';
+export type LifecyclemodelGraphFinding = {
+    severity: 'error' | 'warning';
+    code: string;
+    model_index: number;
+    model_id: string | null;
+    path: string;
+    message: string;
+};
+export type LifecyclemodelGraphModelReport = {
+    index: number;
+    id: string | null;
+    version: string | null;
+    node_count: number;
+    edge_count: number;
+    finding_count: number;
+    files: {
+        graph_json: string | null;
+        dot: string | null;
+        svg: string | null;
+    };
+};
+export type LifecyclemodelGraphReport = {
+    generated_at_utc: string;
+    input_path: string;
+    out_dir: string;
+    format: LifecyclemodelGraphFormat;
+    check_connections: boolean;
+    status: 'completed' | 'completed_with_findings';
+    counts: {
+        models: number;
+        nodes: number;
+        edges: number;
+        findings: number;
+    };
+    files: {
+        report: string;
+        findings: string;
+    };
+    models: LifecyclemodelGraphModelReport[];
+    findings: LifecyclemodelGraphFinding[];
+};
+export type RunLifecyclemodelGraphOptions = {
+    inputPath: string;
+    outDir: string;
+    format?: string | null;
+    checkConnections?: boolean | null;
+    rawInput?: unknown;
+    now?: Date;
+};
+type XflowNode = {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    data: JsonObject;
+};
+type XflowEdge = {
+    id: string;
+    source: {
+        cell?: string;
+    };
+    target: {
+        cell?: string;
+    };
+    data: JsonObject;
+};
+declare function normalizeFormat(value: string | null | undefined): LifecyclemodelGraphFormat;
+declare function asArray(value: unknown): unknown[];
+declare function normalizeNodes(jsonTg: JsonObject): XflowNode[];
+declare function normalizeEdges(jsonTg: JsonObject): XflowEdge[];
+declare function labelFromNode(node: XflowNode): string;
+declare function buildDot(modelId: string | null, nodes: XflowNode[], edges: XflowEdge[]): string;
+declare function buildSvg(nodes: XflowNode[], edges: XflowEdge[]): string;
+declare function checkEdges(modelIndex: number, modelId: string | null, nodes: XflowNode[], edges: XflowEdge[]): LifecyclemodelGraphFinding[];
+declare function safeStem(index: number, id: string | null): string;
+export declare function runLifecyclemodelGraph(options: RunLifecyclemodelGraphOptions): Promise<LifecyclemodelGraphReport>;
+export declare const __testInternals: {
+    asArray: typeof asArray;
+    buildDot: typeof buildDot;
+    buildSvg: typeof buildSvg;
+    checkEdges: typeof checkEdges;
+    labelFromNode: typeof labelFromNode;
+    normalizeFormat: typeof normalizeFormat;
+    normalizeNodes: typeof normalizeNodes;
+    normalizeEdges: typeof normalizeEdges;
+    safeStem: typeof safeStem;
+};
+export {};

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

@@ -0,0 +1,349 @@
+import type { FetchLike } from './http.js';
+type JsonRecord = Record<string, unknown>;
+type OrchestrateAction = 'plan' | 'execute' | 'publish';
+type NodeKind = 'reference_flow' | 'process' | 'lifecyclemodel' | 'resulting_process' | 'subsystem';
+type RequestedAction = 'auto' | 'reuse_existing_resulting_process' | 'reuse_existing_process' | 'reuse_existing_model' | 'build_process' | 'build_submodel' | 'cutoff' | 'unresolved';
+type Resolution = 'unresolved' | 'cutoff' | 'reused_existing_resulting_process' | 'reused_existing_process' | 'reused_existing_model' | 'build_via_process_automated_builder' | 'build_via_lifecyclemodel_automated_builder';
+type InvocationKind = 'process_builder' | 'lifecyclemodel_builder' | 'projector';
+type InvocationStatus = 'success' | 'failed' | 'skipped_due_to_fail_fast' | 'skipped_due_to_dependency_failed' | 'skipped_due_to_dependency_skipped_due_to_fail_fast' | 'skipped_due_to_dependency_skipped_due_to_dependency_failed';
+type Candidate = JsonRecord & {
+    id: string;
+    score: number;
+};
+type ProcessBuilderConfig = {
+    flow_file: string | null;
+    flow_json: unknown;
+    run_id: string | null;
+    publish: boolean;
+    commit: boolean;
+    forward_args: string[];
+};
+type SubmodelBuilderConfig = {
+    manifest: string | null;
+    out_dir: string | null;
+    dry_run: boolean;
+};
+type ProjectorConfig = {
+    command: 'prepare' | 'build' | 'project';
+    request: string | null;
+    model_file: string | null;
+    out_dir: string | null;
+    projection_role: 'primary' | 'all';
+    run_always: boolean;
+    publish_processes: boolean;
+    publish_relations: boolean;
+};
+type OrchestrateNode = {
+    node_id: string;
+    kind: NodeKind;
+    label: string;
+    entity: JsonRecord;
+    requested_action: RequestedAction;
+    depends_on: string[];
+    parent_node_id: string | null;
+    existing_resulting_process_candidates: Candidate[];
+    existing_process_candidates: Candidate[];
+    existing_lifecyclemodel_candidates: Candidate[];
+    process_builder?: ProcessBuilderConfig;
+    submodel_builder?: SubmodelBuilderConfig;
+    projector?: ProjectorConfig;
+    resolution?: Resolution;
+    resolution_reason?: string;
+    selected_candidate?: Candidate | null;
+    boundary_reason?: string | null;
+    planned_invocations: string[];
+};
+type PlanInvocation = {
+    invocation_id: string;
+    node_id: string;
+    kind: InvocationKind;
+    config: JsonRecord;
+    artifact_dir: string;
+    depends_on_invocation_id?: string;
+    last_status?: InvocationStatus;
+    last_exit_code?: number | null;
+    last_result_file?: string | null;
+    artifacts?: JsonRecord;
+};
+type NormalizedPublishConfig = {
+    intent: 'dry_run' | 'prepare_only' | 'publish';
+    prepare_lifecyclemodel_payload: boolean;
+    prepare_resulting_process_payload: boolean;
+    prepare_relation_payload: boolean;
+};
+type ExecutionSummary = {
+    executed_at: string;
+    successful_invocations: number;
+    failed_invocations: number;
+    blocked_invocations: number;
+    status: 'completed' | 'failed';
+};
+type AssemblyPlan = {
+    skill: 'lifecyclemodel-recursive-orchestrator';
+    request_id: string;
+    created_at: string;
+    request_file: string;
+    goal: JsonRecord;
+    root: JsonRecord;
+    orchestration: JsonRecord;
+    candidate_sources: JsonRecord;
+    publish: NormalizedPublishConfig;
+    notes: string[];
+    nodes: OrchestrateNode[];
+    edges: Array<{
+        from: string;
+        to: string;
+        relation: string;
+    }>;
+    invocations: PlanInvocation[];
+    planner_summary: {
+        status: 'planned' | 'executed';
+        message: string;
+    };
+    warnings: string[];
+    unresolved: Array<{
+        node_id: string;
+        label: string;
+        reason: string;
+    }>;
+    boundaries: Array<{
+        node_id: string;
+        reason: string;
+    }>;
+    artifacts: {
+        root: string;
+        request_normalized: string;
+        assembly_plan: string;
+        graph_manifest: string;
+        lineage_manifest: string;
+        boundary_report: string;
+        invocations_dir: string;
+        publish_bundle: string;
+        publish_summary: string;
+    };
+    summary: {
+        node_count: number;
+        edge_count: number;
+        invocation_count: number;
+        unresolved_count: number;
+    };
+    execution_summary?: ExecutionSummary;
+};
+type InvocationExecutionResult = {
+    invocation_id: string;
+    node_id: string;
+    kind: InvocationKind;
+    status: InvocationStatus;
+    exit_code: number | null;
+    result_file: string;
+    planned_artifacts?: JsonRecord;
+    artifacts?: JsonRecord;
+    error?: string;
+    dry_run?: boolean;
+};
+type GraphManifest = {
+    root: JsonRecord;
+    nodes: JsonRecord[];
+    edges: JsonRecord[];
+    boundaries: JsonRecord[];
+    unresolved: JsonRecord[];
+    stats: JsonRecord;
+};
+type LineageManifest = {
+    root_request: JsonRecord;
+    builder_invocations: JsonRecord[];
+    node_resolution_log: JsonRecord[];
+    published_dependencies: JsonRecord[];
+    resulting_process_relations: JsonRecord[];
+    unresolved_history: JsonRecord[];
+};
+export type LifecyclemodelOrchestratePlanReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    action: 'plan';
+    status: 'planned';
+    request_id: string;
+    out_dir: string;
+    counts: {
+        nodes: number;
+        edges: number;
+        invocations: number;
+        unresolved: number;
+    };
+    files: {
+        request_normalized: string;
+        assembly_plan: string;
+        graph_manifest: string;
+        lineage_manifest: string;
+        boundary_report: string;
+    };
+    warnings: string[];
+};
+export type LifecyclemodelOrchestrateExecuteReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    action: 'execute';
+    status: 'completed' | 'failed';
+    request_id: string;
+    out_dir: string;
+    execution: {
+        successful_invocations: number;
+        failed_invocations: number;
+        blocked_invocations: number;
+    };
+    files: {
+        request_normalized: string;
+        assembly_plan: string;
+        graph_manifest: string;
+        lineage_manifest: string;
+        boundary_report: string;
+        invocations_dir: string;
+    };
+    warnings: string[];
+};
+export type LifecyclemodelOrchestratePublishReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    action: 'publish';
+    status: 'prepared_local_publish_bundle';
+    request_id: string;
+    run_dir: string;
+    counts: {
+        lifecyclemodels: number;
+        projected_processes: number;
+        resulting_process_relations: number;
+        process_build_runs: number;
+    };
+    files: {
+        assembly_plan: string;
+        graph_manifest: string;
+        lineage_manifest: string;
+        publish_bundle: string;
+        publish_summary: string;
+    };
+};
+export type LifecyclemodelOrchestrateReport = LifecyclemodelOrchestratePlanReport | LifecyclemodelOrchestrateExecuteReport | LifecyclemodelOrchestratePublishReport;
+export type RunLifecyclemodelOrchestrateOptions = {
+    action: OrchestrateAction;
+    inputPath?: string;
+    outDir?: string | null;
+    runDir?: string;
+    allowProcessBuild?: boolean;
+    allowSubmodelBuild?: boolean;
+    publishLifecyclemodels?: boolean;
+    publishResultingProcessRelations?: boolean;
+    now?: Date;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+};
+declare function invariant<T>(value: T | null | undefined, message: string, details?: JsonRecord): T;
+declare function safeSlug(value: string): string;
+declare function requireObject(value: unknown, label: string): JsonRecord;
+declare function requireEnum<T extends string>(value: unknown, allowed: readonly T[], label: string): T;
+declare function requireBoolean(value: unknown, label: string): boolean;
+declare function requireInteger(value: unknown, label: string): number;
+declare function resolveInputPath(baseDir: string, raw: unknown): string | null;
+declare function defaultCandidateSources(): JsonRecord;
+declare function entityFromRoot(root: JsonRecord): JsonRecord;
+declare function normalizePublishConfig(publish: JsonRecord): NormalizedPublishConfig;
+declare function serializeInvocationConfig(value: ProcessBuilderConfig | SubmodelBuilderConfig | ProjectorConfig | undefined, message: string, details?: JsonRecord): JsonRecord;
+declare function normalizeInvocationFailure(error: unknown): {
+    exit_code: number;
+    error: string;
+};
+declare function normalizeCandidate(raw: unknown): Candidate;
+declare function normalizeCandidateList(value: unknown): Candidate[];
+declare function normalizeRequestedAction(value: unknown): RequestedAction;
+declare function normalizeDependsOn(value: unknown): string[];
+declare function normalizeProcessBuilderConfig(value: unknown, baseDir: string): ProcessBuilderConfig | undefined;
+declare function normalizeSubmodelBuilderConfig(value: unknown, baseDir: string): SubmodelBuilderConfig | undefined;
+declare function normalizeProjectorConfig(value: unknown, baseDir: string): ProjectorConfig | undefined;
+declare function normalizeNode(rawNode: JsonRecord, index: number, baseDir: string): OrchestrateNode;
+declare function deriveRootNode(root: JsonRecord, goal: JsonRecord, baseDir: string): OrchestrateNode;
+declare function buildEdges(requestEdges: unknown[], nodes: OrchestrateNode[]): Array<{
+    from: string;
+    to: string;
+    relation: string;
+}>;
+declare function topoSortNodes(nodes: OrchestrateNode[]): {
+    ordered: OrchestrateNode[];
+    warnings: string[];
+};
+declare function selectResolution(node: OrchestrateNode, orchestration: JsonRecord): {
+    resolution: Resolution;
+    selected_candidate: Candidate | null;
+    reason: string;
+    boundary_reason: string | null;
+};
+declare function shouldRunProjector(node: OrchestrateNode, resolution: Resolution): boolean;
+declare function validateRequestShape(request: JsonRecord): void;
+declare function buildPlan(request: JsonRecord, requestPath: string, outDir: string, now: Date): AssemblyPlan;
+declare function executionStatusByNode(plan: AssemblyPlan, executionResults: InvocationExecutionResult[]): Record<string, string>;
+declare function buildGraphManifest(plan: AssemblyPlan, executionResults: InvocationExecutionResult[]): GraphManifest;
+declare function buildLineageManifest(plan: AssemblyPlan, executionResults: InvocationExecutionResult[]): LineageManifest;
+declare function buildBoundaryReport(plan: AssemblyPlan, executionResults: InvocationExecutionResult[]): JsonRecord;
+declare function requireFile(filePath: string, label: string): void;
+declare function parseInlineJson(value: unknown, label: string): JsonRecord;
+declare function executeProcessBuilderInvocation(invocation: PlanInvocation, plan: AssemblyPlan, resultFile: string, now: Date): Promise<InvocationExecutionResult>;
+declare function executeLifecyclemodelBuilderInvocation(invocation: PlanInvocation, resultFile: string, now: Date): Promise<InvocationExecutionResult>;
+declare function inferProjectorModelFile(invocation: PlanInvocation, executionMap: Map<string, InvocationExecutionResult>): string | null;
+declare function collectProjectorDependencyArtifacts(invocation: PlanInvocation, executionMap: Map<string, InvocationExecutionResult>): {
+    processCatalogPath: string | null;
+    sourceRunDirs: string[];
+};
+declare function buildProjectorRequest(invocation: PlanInvocation, modelFile: string, plan: AssemblyPlan, processCatalogPath: string | null, sourceRunDirs: string[]): JsonRecord;
+declare function executeProjectorInvocation(invocation: PlanInvocation, plan: AssemblyPlan, executionMap: Map<string, InvocationExecutionResult>, resultFile: string, now: Date, env: NodeJS.ProcessEnv, fetchImpl: FetchLike | undefined): Promise<InvocationExecutionResult>;
+declare function executePlan(plan: AssemblyPlan, now: Date, env: NodeJS.ProcessEnv, fetchImpl: FetchLike | undefined): Promise<{
+    results: InvocationExecutionResult[];
+    executionSummary: ExecutionSummary;
+}>;
+declare function loadInvocationResults(invocationsDir: string): InvocationExecutionResult[];
+declare function collectPublishBundle(runDir: string, plan: AssemblyPlan, graphManifest: GraphManifest, lineageManifest: LineageManifest, executionResults: InvocationExecutionResult[], publishLifecyclemodels: boolean, publishResultingProcessRelations: boolean): JsonRecord;
+declare function normalizeRequestForArtifacts(plan: AssemblyPlan): JsonRecord;
+export declare function runLifecyclemodelOrchestrate(options: RunLifecyclemodelOrchestrateOptions): Promise<LifecyclemodelOrchestrateReport>;
+export declare const __testInternals: {
+    invariant: typeof invariant;
+    safeSlug: typeof safeSlug;
+    requireObject: typeof requireObject;
+    requireEnum: typeof requireEnum;
+    requireBoolean: typeof requireBoolean;
+    requireInteger: typeof requireInteger;
+    resolveInputPath: typeof resolveInputPath;
+    defaultCandidateSources: typeof defaultCandidateSources;
+    entityFromRoot: typeof entityFromRoot;
+    normalizeCandidate: typeof normalizeCandidate;
+    normalizeCandidateList: typeof normalizeCandidateList;
+    normalizeRequestedAction: typeof normalizeRequestedAction;
+    normalizeDependsOn: typeof normalizeDependsOn;
+    normalizePublishConfig: typeof normalizePublishConfig;
+    serializeInvocationConfig: typeof serializeInvocationConfig;
+    normalizeInvocationFailure: typeof normalizeInvocationFailure;
+    normalizeProcessBuilderConfig: typeof normalizeProcessBuilderConfig;
+    normalizeSubmodelBuilderConfig: typeof normalizeSubmodelBuilderConfig;
+    normalizeProjectorConfig: typeof normalizeProjectorConfig;
+    normalizeNode: typeof normalizeNode;
+    deriveRootNode: typeof deriveRootNode;
+    buildEdges: typeof buildEdges;
+    topoSortNodes: typeof topoSortNodes;
+    selectResolution: typeof selectResolution;
+    shouldRunProjector: typeof shouldRunProjector;
+    validateRequestShape: typeof validateRequestShape;
+    buildPlan: typeof buildPlan;
+    executionStatusByNode: typeof executionStatusByNode;
+    buildGraphManifest: typeof buildGraphManifest;
+    buildLineageManifest: typeof buildLineageManifest;
+    buildBoundaryReport: typeof buildBoundaryReport;
+    requireFile: typeof requireFile;
+    parseInlineJson: typeof parseInlineJson;
+    inferProjectorModelFile: typeof inferProjectorModelFile;
+    collectProjectorDependencyArtifacts: typeof collectProjectorDependencyArtifacts;
+    executeProcessBuilderInvocation: typeof executeProcessBuilderInvocation;
+    executeLifecyclemodelBuilderInvocation: typeof executeLifecyclemodelBuilderInvocation;
+    executeProjectorInvocation: typeof executeProjectorInvocation;
+    executePlan: typeof executePlan;
+    collectPublishBundle: typeof collectPublishBundle;
+    normalizeRequestForArtifacts: typeof normalizeRequestForArtifacts;
+    loadInvocationResults: typeof loadInvocationResults;
+    buildProjectorRequest: typeof buildProjectorRequest;
+};
+export {};

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

@@ -0,0 +1,77 @@
+type JsonObject = Record<string, unknown>;
+type LifecyclemodelPublishValidationSummary = {
+    available: boolean;
+    ok: boolean | null;
+    report: string | null;
+};
+export type LifecyclemodelPublishBuildLayout = {
+    runId: string;
+    runRoot: string;
+    modelsDir: string;
+    reportsDir: string;
+    manifestsDir: string;
+    publishStageDir: string;
+    runManifestPath: string;
+    invocationIndexPath: string;
+    validationReportPath: string;
+    publishBundlePath: string;
+    publishRequestPath: string;
+    publishIntentPath: string;
+    reportPath: string;
+};
+export type LifecyclemodelPublishBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_local_lifecyclemodel_publish_bundle';
+    run_id: string;
+    run_root: string;
+    counts: {
+        lifecyclemodels: number;
+    };
+    publish_defaults: {
+        commit: boolean;
+        publish_lifecyclemodels: boolean;
+        publish_processes: boolean;
+        publish_sources: boolean;
+        publish_relations: boolean;
+        publish_process_build_runs: boolean;
+        relation_mode: 'local_manifest_only';
+    };
+    validation: LifecyclemodelPublishValidationSummary;
+    files: {
+        run_manifest: string;
+        invocation_index: string;
+        publish_bundle: string;
+        publish_request: string;
+        publish_intent: string;
+        report: string;
+    };
+    next_actions: string[];
+};
+export type RunLifecyclemodelPublishBuildOptions = {
+    runDir: string;
+    now?: Date;
+    cwd?: string;
+};
+declare function buildLayout(runRoot: string): LifecyclemodelPublishBuildLayout;
+declare function resolveLayout(options: RunLifecyclemodelPublishBuildOptions): LifecyclemodelPublishBuildLayout;
+declare function readInvocationIndex(layout: LifecyclemodelPublishBuildLayout): JsonObject;
+declare function collectLifecyclemodelPayloads(layout: LifecyclemodelPublishBuildLayout): JsonObject[];
+declare function readValidationSummary(layout: LifecyclemodelPublishBuildLayout): LifecyclemodelPublishValidationSummary;
+declare function buildPublishRequest(): JsonObject;
+declare function buildPublishIntent(layout: LifecyclemodelPublishBuildLayout, lifecyclemodelCount: number): JsonObject;
+declare function buildInvocationIndex(layout: LifecyclemodelPublishBuildLayout, invocationIndex: JsonObject, options: RunLifecyclemodelPublishBuildOptions, now: Date): JsonObject;
+declare function buildNextActions(layout: LifecyclemodelPublishBuildLayout): string[];
+export declare function runLifecyclemodelPublishBuild(options: RunLifecyclemodelPublishBuildOptions): Promise<LifecyclemodelPublishBuildReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveLayout: typeof resolveLayout;
+    readInvocationIndex: typeof readInvocationIndex;
+    collectLifecyclemodelPayloads: typeof collectLifecyclemodelPayloads;
+    readValidationSummary: typeof readValidationSummary;
+    buildPublishRequest: typeof buildPublishRequest;
+    buildPublishIntent: typeof buildPublishIntent;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+};
+export {};

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

@@ -0,0 +1,27 @@
+type JsonObject = Record<string, unknown>;
+export type LifecyclemodelPublishResultingProcessReport = {
+    generated_at_utc: string;
+    run_dir: string;
+    status: 'prepared_local_publish_bundle';
+    publish_processes: boolean;
+    publish_relations: boolean;
+    counts: {
+        projected_processes: number;
+        relations: number;
+    };
+    source_model: JsonObject;
+    files: {
+        projection_bundle: string;
+        projection_report: string;
+        publish_bundle: string;
+        publish_intent: string;
+    };
+};
+export type RunLifecyclemodelPublishResultingProcessOptions = {
+    runDir: string;
+    publishProcesses: boolean;
+    publishRelations: boolean;
+    now?: Date;
+};
+export declare function runLifecyclemodelPublishResultingProcess(options: RunLifecyclemodelPublishResultingProcessOptions): Promise<LifecyclemodelPublishResultingProcessReport>;
+export {};