@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/tidas-sdk-package-validator.d.ts

@@ -0,0 +1,111 @@
+import { type SafeParseIssue, type SafeParseSchema, type SdkValidationFactory } from './tidas-sdk-validation.js';
+type JsonObject = Record<string, unknown>;
+export type ValidationSeverity = 'error' | 'warning' | 'info';
+export type ValidationIssue = {
+    issue_code: string;
+    severity: ValidationSeverity;
+    category: string;
+    file_path: string;
+    message: string;
+    location: string;
+    context: Record<string, unknown>;
+};
+type ValidationSummary = {
+    issue_count: number;
+    error_count: number;
+    warning_count: number;
+    info_count: number;
+};
+type CategoryValidationReport = {
+    category: string;
+    ok: boolean;
+    summary: ValidationSummary;
+    issues: ValidationIssue[];
+};
+export type PackageValidationReport = {
+    input_dir: string;
+    ok: boolean;
+    summary: ValidationSummary & {
+        category_count: number;
+    };
+    categories: CategoryValidationReport[];
+    issues: ValidationIssue[];
+};
+type SupportedCategory = 'contacts' | 'flowproperties' | 'flows' | 'lciamethods' | 'lifecyclemodels' | 'processes' | 'sources' | 'unitgroups';
+type TidasSdkPublicModule = {
+    ContactSchema?: SafeParseSchema;
+    FlowPropertySchema?: SafeParseSchema;
+    FlowSchema?: SafeParseSchema;
+    LCIAMethodSchema?: SafeParseSchema;
+    LifeCycleModelSchema?: SafeParseSchema;
+    ProcessSchema?: SafeParseSchema;
+    SourceSchema?: SafeParseSchema;
+    UnitGroupSchema?: SafeParseSchema;
+    createContact?: SdkValidationFactory;
+    createFlowProperty?: SdkValidationFactory;
+    createFlow?: SdkValidationFactory;
+    createLCIAMethod?: SdkValidationFactory;
+    createLifeCycleModel?: SdkValidationFactory;
+    createProcess?: SdkValidationFactory;
+    createSource?: SdkValidationFactory;
+    createUnitGroup?: SdkValidationFactory;
+};
+declare function summarizeIssues(issues: ValidationIssue[]): ValidationSummary;
+declare function buildCategoryReport(category: string, issues: ValidationIssue[]): CategoryValidationReport;
+declare function buildPackageReport(inputDir: string, categoryReports: CategoryValidationReport[]): PackageValidationReport;
+declare function asRecord(value: unknown): JsonObject | null;
+declare function ensureArray<T>(value: T | T[] | undefined | null): T[];
+declare function toLocation(pathParts: Array<string | number> | undefined): string;
+declare function createInvalidJsonIssue(category: string, filePath: string, error: unknown): ValidationIssue;
+declare function createValidationErrorIssue(category: string, filePath: string, error: unknown): ValidationIssue;
+declare function createSchemaIssue(category: string, filePath: string, issue: SafeParseIssue): ValidationIssue;
+declare function dedupeIssues(issues: ValidationIssue[]): ValidationIssue[];
+declare function makeIssue(category: string, filePath: string, location: string, message: string, issueCode?: string): ValidationIssue;
+export declare function validateElementaryFlowsClassificationHierarchy(classItems: Array<Record<string, unknown>>): string[];
+export declare function validateProductFlowsClassificationHierarchy(classItems: Array<Record<string, unknown>>): string[];
+export declare function validateProcessesClassificationHierarchy(classItems: Array<Record<string, unknown>>): string[];
+declare function validateSourcesClassificationHierarchy(classItems: Array<Record<string, unknown>> | Record<string, unknown> | undefined): string[];
+declare function validateLocalizedTextLanguageConstraints(node: unknown, currentPath?: string): string[];
+declare function collectFlowClassificationStructureIssues(items: unknown, category: string, filePath: string, locationBase: string, requiredIdKey: '@classId' | '@catId'): ValidationIssue[];
+declare function extractLocalizedTextLocation(message: string): string;
+declare function collectLocalizedTextIssues(jsonItem: unknown, category: string, filePath: string): ValidationIssue[];
+declare function collectFlowSchemaGapIssues(jsonItem: unknown, category: string, filePath: string): ValidationIssue[];
+export declare function collectClassificationIssues(jsonItem: unknown, category: string, filePath: string): ValidationIssue[];
+declare function collectSchemaIssues(schema: SafeParseSchema, jsonItem: unknown, category: SupportedCategory, filePath: string, createEntity?: SdkValidationFactory | null): ValidationIssue[];
+declare function categoryValidate(jsonFilePath: string, category: SupportedCategory, schema: SafeParseSchema, createEntity?: SdkValidationFactory | null, emitLogs?: boolean): CategoryValidationReport;
+declare function resolveCategorySchemas(moduleExports: TidasSdkPublicModule): Map<SupportedCategory, {
+    schema: SafeParseSchema;
+    createEntity: SdkValidationFactory | null;
+}> | null;
+export declare function createTidasSdkPackageValidator(moduleExports: TidasSdkPublicModule, location: string): {
+    location: string;
+    validatePackageDir: (inputDir: string, emitLogs?: boolean) => PackageValidationReport;
+} | null;
+export declare const __testInternals: {
+    summarizeIssues: typeof summarizeIssues;
+    buildCategoryReport: typeof buildCategoryReport;
+    buildPackageReport: typeof buildPackageReport;
+    asRecord: typeof asRecord;
+    ensureArray: typeof ensureArray;
+    toLocation: typeof toLocation;
+    createInvalidJsonIssue: typeof createInvalidJsonIssue;
+    createValidationErrorIssue: typeof createValidationErrorIssue;
+    createSchemaIssue: typeof createSchemaIssue;
+    dedupeIssues: typeof dedupeIssues;
+    makeIssue: typeof makeIssue;
+    validateElementaryFlowsClassificationHierarchy: typeof validateElementaryFlowsClassificationHierarchy;
+    validateProductFlowsClassificationHierarchy: typeof validateProductFlowsClassificationHierarchy;
+    validateProcessesClassificationHierarchy: typeof validateProcessesClassificationHierarchy;
+    validateSourcesClassificationHierarchy: typeof validateSourcesClassificationHierarchy;
+    validateLocalizedTextLanguageConstraints: typeof validateLocalizedTextLanguageConstraints;
+    collectFlowClassificationStructureIssues: typeof collectFlowClassificationStructureIssues;
+    extractLocalizedTextLocation: typeof extractLocalizedTextLocation;
+    collectLocalizedTextIssues: typeof collectLocalizedTextIssues;
+    collectFlowSchemaGapIssues: typeof collectFlowSchemaGapIssues;
+    collectClassificationIssues: typeof collectClassificationIssues;
+    collectSchemaIssues: typeof collectSchemaIssues;
+    categoryValidate: typeof categoryValidate;
+    CATEGORY_FACTORY_EXPORTS: Record<SupportedCategory, keyof TidasSdkPublicModule>;
+    resolveCategorySchemas: typeof resolveCategorySchemas;
+};
+export {};

package/dist/src/lib/tidas-sdk-validation.d.ts

@@ -0,0 +1,42 @@
+export type SafeParseIssue = {
+    code?: string;
+    message?: string;
+    path?: Array<string | number>;
+};
+export type SafeParseResult = {
+    success: true;
+    data?: unknown;
+} | {
+    success: false;
+    error?: {
+        issues?: SafeParseIssue[];
+    };
+};
+export type SafeParseSchema = {
+    safeParse: (value: unknown) => SafeParseResult;
+};
+export type EntityValidationConfig = {
+    mode: 'strict';
+    throwOnError: false;
+    deepValidation: boolean;
+};
+export type SdkValidationEntity = {
+    validateEnhanced?: () => unknown;
+    validate?: () => unknown;
+};
+export type SdkValidationFactory = (data?: unknown, validationConfig?: EntityValidationConfig) => SdkValidationEntity | unknown;
+export type SchemaValidationOutcome = {
+    success: true;
+    issues: [];
+    result: SafeParseResult;
+} | {
+    success: false;
+    issues: SafeParseIssue[];
+    result: unknown;
+};
+export declare function validationSucceeded(result: unknown): boolean;
+export declare function validationIssues(result: unknown): SafeParseIssue[];
+export declare function normalizeIssuePath(pathParts: Array<string | number> | undefined, separator?: string): string;
+export declare function runEntityValidation(entity: unknown): unknown | null;
+export declare function validateEntityWithDeepFallback(payload: unknown, createEntity: SdkValidationFactory): unknown | null;
+export declare function validateSchemaWithDeepFallback(schema: SafeParseSchema, payload: unknown, createEntity?: SdkValidationFactory | null): SchemaValidationOutcome;

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

@@ -0,0 +1,32 @@
+import type { EnvSpec } from './env.js';
+import type { FetchLike } from './http.js';
+export declare const UNSTRUCTURED_ENV_KEYS: {
+    readonly apiBaseUrl: 'TIANGONG_LCA_UNSTRUCTURED_API_BASE_URL';
+    readonly apiKey: 'TIANGONG_LCA_UNSTRUCTURED_API_KEY';
+    readonly provider: 'TIANGONG_LCA_UNSTRUCTURED_PROVIDER';
+    readonly model: 'TIANGONG_LCA_UNSTRUCTURED_MODEL';
+    readonly chunkType: 'TIANGONG_LCA_UNSTRUCTURED_CHUNK_TYPE';
+    readonly returnTxt: 'TIANGONG_LCA_UNSTRUCTURED_RETURN_TXT';
+};
+export declare const UNSTRUCTURED_ENV_SPECS: EnvSpec[];
+export type UnstructuredRuntimeEnv = {
+    apiBaseUrl: string | null;
+    apiKey: string | null;
+    provider: string | null;
+    model: string | null;
+    chunkType: boolean;
+    returnTxt: boolean;
+};
+export type ParseUnstructuredDocumentOptions = {
+    env: UnstructuredRuntimeEnv;
+    filePath: string;
+    prompt?: string | null;
+    provider?: string | null;
+    model?: string | null;
+    chunkType?: boolean;
+    returnTxt?: boolean;
+    timeoutMs: number;
+    fetchImpl: FetchLike;
+};
+export declare function readUnstructuredRuntimeEnv(env: NodeJS.ProcessEnv): UnstructuredRuntimeEnv;
+export declare function parseUnstructuredDocument(options: ParseUnstructuredDocumentOptions): Promise<unknown>;

package/dist/src/lib/user-api-key.d.ts

@@ -0,0 +1,16 @@
+export type UserApiKeyCredentials = {
+    email: string;
+    password: string;
+};
+declare function normalizeToken(value: unknown): string;
+declare function normalizeCredentialValue(value: unknown): string;
+export declare function decodeUserApiKey(apiKey: string): UserApiKeyCredentials | null;
+export declare function requireUserApiKeyCredentials(apiKey: string): UserApiKeyCredentials;
+export declare function fingerprintSecret(value: string): string;
+export declare function fingerprintUserApiKey(apiKey: string): string;
+export declare function redactEmail(email: string): string;
+export declare const __testInternals: {
+    normalizeCredentialValue: typeof normalizeCredentialValue;
+    normalizeToken: typeof normalizeToken;
+};
+export {};

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

@@ -0,0 +1,82 @@
+export declare function resolveRepoRootFrom(startDir: string): string;
+export type ValidationSeverity = 'error' | 'warning' | 'info';
+export type ValidationIssue = {
+    issue_code: string;
+    severity: ValidationSeverity;
+    category: string;
+    file_path: string;
+    message: string;
+    location: string;
+    context: Record<string, unknown>;
+};
+export type ValidationSummary = {
+    issue_count: number;
+    error_count: number;
+    warning_count: number;
+    info_count: number;
+};
+export type CategoryValidationReport = {
+    category: string;
+    ok: boolean;
+    summary: ValidationSummary;
+    issues: ValidationIssue[];
+};
+export type PackageValidationReport = {
+    input_dir: string;
+    ok: boolean;
+    summary: ValidationSummary & {
+        category_count: number;
+    };
+    categories: CategoryValidationReport[];
+    issues: ValidationIssue[];
+};
+export type ValidationEngine = 'sdk';
+export type ValidationMode = 'auto' | 'sdk';
+export type ValidationExecutionReport = {
+    engine: ValidationEngine;
+    ok: boolean;
+    duration_ms: number;
+    location: string;
+    report: PackageValidationReport;
+    command?: string[];
+    command_exit_code?: number | null;
+};
+export type ValidationComparison = {
+    equivalent: boolean;
+    differences: string[];
+};
+export type ValidationRunReport = {
+    input_dir: string;
+    mode: ValidationMode;
+    ok: boolean;
+    summary: {
+        engine_count: number;
+        ok_count: number;
+        failed_count: number;
+    };
+    files: {
+        report: string | null;
+    };
+    reports: ValidationExecutionReport[];
+    comparison: ValidationComparison | null;
+};
+export type RunValidationOptions = {
+    inputDir: string;
+    engine?: string;
+    reportFile?: string | null;
+};
+export type ValidationDeps = {
+    loadSdkModule?: () => {
+        location: string;
+        validatePackageDir: (inputDir: string, emitLogs?: boolean) => unknown;
+    };
+};
+export declare function resolveSdkModuleFromCandidates(requireFn: (candidate: string) => unknown, candidates: string[]): {
+    location: string;
+    validatePackageDir: (inputDir: string, emitLogs?: boolean) => unknown;
+};
+export declare function resolveLocalSdkModule(): {
+    location: string;
+    validatePackageDir: (inputDir: string, emitLogs?: boolean) => unknown;
+};
+export declare function runValidation(options: RunValidationOptions, deps?: ValidationDeps): Promise<ValidationRunReport>;

package/dist/src/main.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function main(argv: string[], env?: NodeJS.ProcessEnv): Promise<number>;
+export declare function isDirectEntry(importMetaUrl: string, argv1: string | undefined): boolean;
+export declare function maybeRunFromProcess(argv?: string[], env?: NodeJS.ProcessEnv, importMetaUrl?: string): Promise<number | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiangong-lca/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Unified TianGong LCA CLI with direct REST adapters and low-entropy command surface.",
   "repository": {
     "type": "git",
@@ -14,6 +14,17 @@
   "bin": {
     "tiangong-lca": "./bin/tiangong-lca.js"
   },
+  "exports": {
+    "./bin/tiangong-lca.js": "./bin/tiangong-lca.js",
+    "./command-spec": {
+      "types": "./dist/src/command-spec.d.ts",
+      "import": "./dist/src/command-spec.js"
+    },
+    "./batch": {
+      "types": "./dist/src/batch.d.ts",
+      "import": "./dist/src/batch.js"
+    }
+  },
   "files": [
     "assets/",
     "bin/",
@@ -32,8 +43,8 @@
     ]
   },
   "engines": {
-    "node": ">=24 <25",
-    "pnpm": "11.23.0"
+    "node": ">=24.19.0 <25",
+    "pnpm": "11.24.0"
   },
   "keywords": [
     "tiangong-lca",
@@ -49,6 +60,7 @@
     "oxlint": "^1.80.0",
     "oxlint-tsgolint": "^7.0.2001",
     "prettier": "3.8.1",
+    "sigstore": "5.0.0",
     "tsx": "^4.23.12",
     "typescript": "^7.0.2"
   },
@@ -74,9 +86,11 @@
     "test:package": "node --test test/toolchain-contract.test.mjs",
     "test:coverage": "pnpm build && node ./scripts/run-test-coverage.cjs",
     "test:coverage:assert-full": "node ./dist/scripts/assert-full-coverage.js",
+    "case:auth-identity:production": "pnpm build && node ./dist/scripts/run-auth-identity-production-case.js",
     "prepush:gate": "pnpm lint && pnpm test:package && pnpm test:coverage && pnpm test:coverage:assert-full",
     "release:check-tag": "node ./scripts/ci/check-release-tag.cjs cli",
     "release:assert-unpublished": "node ./scripts/ci/release-version.cjs assert-unpublished",
+    "release:verify-published": "node ./scripts/ci/verify-published-release.cjs",
     "clean": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { recursive: true, force: true }))\""
   }
 }