@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/dataset-bilingual.d.ts

@@ -0,0 +1,165 @@
+import { materializeDatasetRows, type DatasetKind } from './dataset-local.js';
+import { type DatasetValidateReport, type RunDatasetValidateOptions } from './dataset-validate.js';
+import { type FlowQaReport, type RunFlowQaOptions } from './flow-qa.js';
+import { type ProcessQaReport, type RunProcessQaOptions } from './process-qa.js';
+type BilingualDatasetType = 'auto' | DatasetKind;
+type BilingualStatus = 'completed' | 'blocked';
+type ScanSeverity = 'warning' | 'blocker';
+export type BilingualTranslationUnit = {
+    schema_version: 1;
+    unit_id: string;
+    row_index: number;
+    dataset_type: DatasetKind | null;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    field_path: string;
+    source_lang: string;
+    target_lang: string;
+    source_text: string;
+    current_target_text: string | null;
+    context: {
+        root_field: string | null;
+        sibling_keys: string[];
+    };
+};
+export type DatasetBilingualExtractReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    input_path: string;
+    requested_type: BilingualDatasetType;
+    source_lang: string;
+    target_lang: string;
+    unit_count: number;
+    row_count: number;
+    files: {
+        translation_units: string | null;
+        report: string | null;
+    };
+};
+export type TranslationEvidenceEntry = {
+    unit_id: string;
+    row_index: number;
+    dataset_type: DatasetKind | null;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    field_path: string;
+    source_lang: string;
+    target_lang: string;
+    source_text: string;
+    translated_text: string;
+    basis: string | null;
+    review_status: string | null;
+    reviewer: string | null;
+};
+export type DatasetBilingualApplyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    input_path: string;
+    translations_path: string;
+    out_path: string;
+    target_lang: string;
+    status: BilingualStatus;
+    row_count: number;
+    translation_count: number;
+    applied_count: number;
+    skipped_count: number;
+    blockers: Array<{
+        code: string;
+        message: string;
+        unit_id?: string;
+    }>;
+    files: {
+        translated_rows: string;
+        translation_evidence: string | null;
+        report: string | null;
+    };
+};
+export type BilingualScanFinding = {
+    code: string;
+    severity: ScanSeverity;
+    row_index: number;
+    dataset_type: DatasetKind | null;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    field_path: string;
+    lang: string | null;
+    message: string;
+    text_preview: string;
+};
+export type DatasetBilingualValidateReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    input_path: string;
+    requested_type: BilingualDatasetType;
+    status: BilingualStatus;
+    row_count: number;
+    scan: {
+        finding_count: number;
+        blocker_count: number;
+        warning_count: number;
+        findings: BilingualScanFinding[];
+    };
+    schema_gate: {
+        status: DatasetValidateReport['status'];
+        valid: number;
+        invalid: number;
+        report_file: string | null;
+    };
+    qa_gate: {
+        status: 'completed' | 'not_run';
+        process_report_file: string | null;
+        flow_report_file: string | null;
+    };
+    files: {
+        report: string | null;
+        findings: string | null;
+    };
+};
+export type RunDatasetBilingualExtractOptions = {
+    inputPath: string;
+    type?: string | null;
+    outDir?: string | null;
+    sourceLang?: string | null;
+    targetLang?: string | null;
+    rawInput?: unknown;
+    now?: Date;
+};
+export type RunDatasetBilingualApplyOptions = {
+    inputPath: string;
+    translationsPath: string;
+    outPath: string;
+    outDir?: string | null;
+    targetLang?: string | null;
+    rawInput?: unknown;
+    rawTranslations?: unknown;
+    now?: Date;
+};
+export type RunDatasetBilingualValidateOptions = {
+    inputPath: string;
+    type?: string | null;
+    outDir?: string | null;
+    rawInput?: unknown;
+    now?: Date;
+    datasetValidateImpl?: (options: RunDatasetValidateOptions) => Promise<DatasetValidateReport>;
+    processQaImpl?: (options: RunProcessQaOptions) => Promise<ProcessQaReport>;
+    flowQaImpl?: (options: RunFlowQaOptions) => Promise<FlowQaReport>;
+    schemas?: RunDatasetValidateOptions['schemas'];
+};
+declare function normalizeType(value: string | null | undefined): BilingualDatasetType;
+declare function pointerFromSegments(segments: string[]): string;
+declare function segmentsFromPointer(pointer: string): string[];
+declare function rawLangOf(value: unknown): string | null;
+declare function collectTranslationUnits(rows: ReturnType<typeof materializeDatasetRows>, sourceLang: string, targetLang: string): BilingualTranslationUnit[];
+declare function scanRows(rows: ReturnType<typeof materializeDatasetRows>): BilingualScanFinding[];
+export declare function runDatasetBilingualExtract(options: RunDatasetBilingualExtractOptions): Promise<DatasetBilingualExtractReport>;
+export declare function runDatasetBilingualApply(options: RunDatasetBilingualApplyOptions): Promise<DatasetBilingualApplyReport>;
+export declare function runDatasetBilingualValidate(options: RunDatasetBilingualValidateOptions): Promise<DatasetBilingualValidateReport>;
+export declare const __testInternals: {
+    collectTranslationUnits: typeof collectTranslationUnits;
+    normalizeType: typeof normalizeType;
+    pointerFromSegments: typeof pointerFromSegments;
+    rawLangOf: typeof rawLangOf;
+    segmentsFromPointer: typeof segmentsFromPointer;
+    scanRows: typeof scanRows;
+};
+export {};

package/dist/src/lib/dataset-classification.d.ts

@@ -0,0 +1,279 @@
+import { type JsonObject } from './dataset-local.js';
+export type DatasetClassificationType = 'contact' | 'flow-elementary' | 'flow-product' | 'flowproperty' | 'lciamethod' | 'location' | 'process' | 'source' | 'unitgroup';
+type ClassificationValueKey = '@catId' | '@classId' | '@code';
+export type ClassificationEntry = {
+    level: number;
+    code: string;
+    text: string;
+    value_key: ClassificationValueKey;
+};
+export type ClassificationPathEntry = {
+    '@level': string;
+    '@classId'?: string;
+    '@catId'?: string;
+    '@code'?: string;
+    '#text': string;
+};
+export type DatasetClassificationChildrenReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'blocked';
+    command: 'dataset classification children';
+    category_type: DatasetClassificationType;
+    schema_file: string;
+    parent_code: string | null;
+    query: string | null;
+    counts: {
+        children: number;
+        returned: number;
+    };
+    children: Array<ClassificationEntry & {
+        path: ClassificationPathEntry[];
+    }>;
+    blockers: Array<{
+        code: string;
+        message: string;
+    }>;
+    files?: {
+        report: string;
+    };
+};
+export type DatasetClassificationPathReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'blocked';
+    command: 'dataset classification path';
+    category_type: DatasetClassificationType;
+    schema_file: string;
+    code: string;
+    path: ClassificationPathEntry[];
+    blockers: Array<{
+        code: string;
+        message: string;
+    }>;
+    files?: {
+        report: string;
+    };
+};
+export type DatasetClassificationApplyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'blocked';
+    command: 'dataset classification apply';
+    input_path: string;
+    decisions_path: string;
+    out_path: string;
+    default_category_type: DatasetClassificationType | null;
+    counts: {
+        rows: number;
+        decisions: number;
+        applied: number;
+        blockers: number;
+    };
+    blockers: DatasetClassificationBlocker[];
+    files: {
+        classified_rows: string;
+        evidence: string;
+        report: string;
+    };
+};
+export type DatasetClassificationAuditFinding = {
+    row_index: number;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    path: string;
+    value: string;
+    status: 'valid' | 'invalid';
+    description: string | null;
+};
+export type DatasetClassificationAuditReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'blocked';
+    command: 'dataset classification audit';
+    category_type: DatasetClassificationType;
+    schema_file: string;
+    input_path: string;
+    counts: {
+        rows: number;
+        location_targets: number;
+        valid: number;
+        invalid: number;
+    };
+    findings: DatasetClassificationAuditFinding[];
+    blockers: DatasetClassificationBlocker[];
+    files?: {
+        findings: string;
+        report: string;
+    };
+};
+export type DatasetClassificationBlocker = {
+    code: string;
+    message: string;
+    decision_index?: number;
+    row_index?: number;
+    dataset_id?: string | null;
+    dataset_version?: string | null;
+};
+export type RunDatasetClassificationChildrenOptions = {
+    type: string;
+    parent?: string | null;
+    query?: string | null;
+    limit?: number | null;
+    outDir?: string | null;
+    now?: Date;
+};
+export type RunDatasetClassificationPathOptions = {
+    type: string;
+    code: string;
+    outDir?: string | null;
+    now?: Date;
+};
+export type RunDatasetClassificationAuditOptions = {
+    inputPath: string;
+    type: string;
+    outDir?: string | null;
+    rawInput?: unknown;
+    now?: Date;
+};
+export type RunDatasetClassificationApplyOptions = {
+    inputPath: string;
+    decisionsPath: string;
+    outPath: string;
+    type?: string | null;
+    outDir?: string | null;
+    rawInput?: unknown;
+    rawDecisions?: unknown;
+    now?: Date;
+};
+type CategoryConfig = {
+    type: DatasetClassificationType;
+    schemaFile: string;
+    defaultValueKey: ClassificationValueKey;
+    target: 'common:category' | 'common:class' | 'location';
+};
+type ClassificationNavigator = {
+    entries: ClassificationEntry[];
+    entriesByCode: Map<string, ClassificationEntry>;
+    childMap: Map<string, ClassificationEntry[]>;
+    parentMap: Map<string, ClassificationEntry | null>;
+};
+type NormalizedDecision = {
+    decisionIndex: number;
+    rowIndex: number | null;
+    datasetId: string | null;
+    datasetVersion: string | null;
+    categoryType: DatasetClassificationType;
+    path: ClassificationPathEntry[];
+    targetPath: string | null;
+    basis: string | null;
+    evidence: unknown;
+};
+type LocationTarget = {
+    path: string;
+    parentPath: string;
+    parent: JsonObject;
+    key: string;
+    value: string;
+};
+type PreparedClassificationRow = {
+    index: number;
+    row: JsonObject;
+    payload: JsonObject;
+    rootKey: string | null;
+    informationKey: string | null;
+    id: string | null;
+    version: string | null;
+};
+declare function normalizeType(value: unknown): DatasetClassificationType;
+declare function schemasDir(candidatesOverride?: string[]): string;
+declare function lastSchemaPropertyName(schemaPathSegments: string[]): string | null;
+declare function collectLocationRefKeysFromSchema(value: unknown, schemaPathSegments: string[], keys: Set<string>): void;
+declare function locationTargetKeys(): Set<string>;
+declare function isJsonSchemaFileName(fileName: string): boolean;
+declare function constText(value: unknown): string | null;
+declare function collectEntriesFromNode(node: unknown, defaultValueKey: ClassificationValueKey, entries: ClassificationEntry[]): void;
+declare function loadEntries(type: DatasetClassificationType): {
+    config: CategoryConfig;
+    schema: string;
+    entries: ClassificationEntry[];
+};
+declare function buildNavigator(entries: ClassificationEntry[]): ClassificationNavigator;
+declare function navigatorFor(type: DatasetClassificationType): {
+    config: CategoryConfig;
+    schema: string;
+    navigator: ClassificationNavigator;
+};
+declare function pathForCode(navigator: ClassificationNavigator, code: string): ClassificationEntry[];
+declare function toPathEntry(entry: ClassificationEntry): ClassificationPathEntry;
+declare function classCode(value: unknown): string | null;
+declare function normalizeTargetPath(value: unknown): string | null;
+declare function decisionTargetPath(decision: JsonObject): string | null;
+declare function normalizePathFromClasses(type: DatasetClassificationType, classes: unknown): ClassificationPathEntry[];
+declare function normalizePathFromDecision(type: DatasetClassificationType, decision: JsonObject): ClassificationPathEntry[];
+declare function normalizeDecisionType(decision: JsonObject, fallbackType: DatasetClassificationType | null): DatasetClassificationType | null;
+declare function normalizeStructuredDecisions(value: unknown): JsonObject[];
+declare function readDecisions(pathValue: string, rawInput?: unknown): JsonObject[];
+declare function prepareRows(inputPath: string, rawInput?: unknown): PreparedClassificationRow[];
+declare function classificationContainer(row: PreparedClassificationRow, type: DatasetClassificationType): JsonObject | null;
+declare function currentClassification(row: PreparedClassificationRow, type: DatasetClassificationType): unknown;
+declare function setClassification(row: PreparedClassificationRow, type: DatasetClassificationType, classificationPath: ClassificationPathEntry[]): boolean;
+declare function locationTargetStringValue(value: unknown): {
+    parent: JsonObject | null;
+    key: string | null;
+    pathSuffix: Array<string | number>;
+    value: string;
+} | null;
+declare function collectLocationTargets(value: unknown, pathSegments?: Array<string | number>, targets?: LocationTarget[]): LocationTarget[];
+declare function locationCodeFromPath(classificationPath: ClassificationPathEntry[]): string | null;
+declare function resolveLocationTarget(row: PreparedClassificationRow, decision: NormalizedDecision): LocationTarget[];
+declare function targetPathSegments(targetPath: string): string[];
+declare function createMissingLocationTarget(row: PreparedClassificationRow, targetPath: string): LocationTarget | null;
+declare function decisionMatchesRow(decision: NormalizedDecision, row: PreparedClassificationRow): boolean;
+declare function normalizeDecision(decision: JsonObject, decisionIndex: number, fallbackType: DatasetClassificationType | null, blockers: DatasetClassificationBlocker[]): NormalizedDecision | null;
+declare function maybeWriteReport<T extends {
+    files?: {
+        report: string;
+    };
+}>(report: T, outDir: string | null | undefined, filename: string): T;
+export declare function runDatasetClassificationChildren(options: RunDatasetClassificationChildrenOptions): Promise<DatasetClassificationChildrenReport>;
+export declare function runDatasetClassificationPath(options: RunDatasetClassificationPathOptions): Promise<DatasetClassificationPathReport>;
+export declare function runDatasetClassificationAudit(options: RunDatasetClassificationAuditOptions): Promise<DatasetClassificationAuditReport>;
+export declare function runDatasetClassificationApply(options: RunDatasetClassificationApplyOptions): Promise<DatasetClassificationApplyReport>;
+export declare const __testInternals: {
+    buildNavigator: typeof buildNavigator;
+    classCode: typeof classCode;
+    classificationContainer: typeof classificationContainer;
+    collectEntriesFromNode: typeof collectEntriesFromNode;
+    collectLocationRefKeysFromSchema: typeof collectLocationRefKeysFromSchema;
+    collectLocationTargets: typeof collectLocationTargets;
+    constText: typeof constText;
+    createMissingLocationTarget: typeof createMissingLocationTarget;
+    currentClassification: typeof currentClassification;
+    decisionMatchesRow: typeof decisionMatchesRow;
+    decisionTargetPath: typeof decisionTargetPath;
+    isJsonSchemaFileName: typeof isJsonSchemaFileName;
+    lastSchemaPropertyName: typeof lastSchemaPropertyName;
+    loadEntries: typeof loadEntries;
+    locationCodeFromPath: typeof locationCodeFromPath;
+    locationTargetStringValue: typeof locationTargetStringValue;
+    locationTargetKeys: typeof locationTargetKeys;
+    maybeWriteReport: typeof maybeWriteReport;
+    navigatorFor: typeof navigatorFor;
+    normalizeDecision: typeof normalizeDecision;
+    normalizeDecisionType: typeof normalizeDecisionType;
+    normalizePathFromClasses: typeof normalizePathFromClasses;
+    normalizePathFromDecision: typeof normalizePathFromDecision;
+    normalizeStructuredDecisions: typeof normalizeStructuredDecisions;
+    normalizeTargetPath: typeof normalizeTargetPath;
+    normalizeType: typeof normalizeType;
+    pathForCode: typeof pathForCode;
+    prepareRows: typeof prepareRows;
+    readDecisions: typeof readDecisions;
+    resolveLocationTarget: typeof resolveLocationTarget;
+    schemasDir: typeof schemasDir;
+    setClassification: typeof setClassification;
+    targetPathSegments: typeof targetPathSegments;
+    toPathEntry: typeof toPathEntry;
+};
+export {};

package/dist/src/lib/dataset-command.d.ts

@@ -0,0 +1,53 @@
+import type { FetchLike } from './http.js';
+import { type SupabaseDataRuntime } from './supabase-client.js';
+type JsonObject = Record<string, unknown>;
+export type DatasetCommandTable = 'contacts' | 'sources' | 'unitgroups' | 'flowproperties' | 'flows' | 'processes' | 'lifecyclemodels';
+export type DatasetCommandTransport = {
+    functionsBaseUrl: string;
+    publishableKey: string;
+    accessToken: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+};
+declare function readOptionalRuleVerification(extraData?: JsonObject): boolean | null | undefined;
+declare function readOptionalModelId(extraData: JsonObject | undefined, allowNull: boolean): string | null | undefined;
+export declare function deriveSupabaseFunctionsBaseUrl(apiBaseUrl: string): string;
+export declare function buildDatasetCommandTransport(options: {
+    runtime: SupabaseDataRuntime;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+}): Promise<DatasetCommandTransport>;
+export declare function resolveDatasetCommandTransport(options: {
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+}): Promise<DatasetCommandTransport>;
+export declare function createDatasetRecord(options: {
+    transport: DatasetCommandTransport;
+    table: DatasetCommandTable;
+    id: string;
+    payload: JsonObject;
+    extraData?: JsonObject;
+    beforeDispatch?: () => void;
+}): Promise<JsonObject>;
+export declare function saveDraftDatasetRecord(options: {
+    transport: DatasetCommandTransport;
+    table: DatasetCommandTable;
+    id: string;
+    version: string;
+    payload: JsonObject;
+    extraData?: JsonObject;
+    beforeDispatch?: () => void;
+}): Promise<JsonObject>;
+export declare function deleteDatasetRecord(options: {
+    transport: DatasetCommandTransport;
+    table: DatasetCommandTable;
+    id: string;
+    version: string;
+}): Promise<JsonObject>;
+export declare const __testInternals: {
+    deriveSupabaseFunctionsBaseUrl: typeof deriveSupabaseFunctionsBaseUrl;
+    readOptionalModelId: typeof readOptionalModelId;
+    readOptionalRuleVerification: typeof readOptionalRuleVerification;
+};
+export {};

package/dist/src/lib/dataset-contract.d.ts

@@ -0,0 +1,82 @@
+export type DatasetContractInclude = 'schema' | 'methodology' | 'ruleset';
+export type DatasetContractProfile = 'default' | 'ai-import';
+export type DatasetContractMode = 'contract' | 'context-pack';
+export type DatasetContractReport = {
+    schema_version: 1;
+    status: 'completed';
+    generated_at_utc: string;
+    mode: DatasetContractMode;
+    requested_type: string;
+    type: string;
+    profile: DatasetContractProfile;
+    includes: DatasetContractInclude[];
+    source: 'sdk-contract-api' | 'sdk-runtime-assets';
+    manifest: unknown;
+    files: {
+        manifest: string;
+        schema: string | null;
+        methodology: string | null;
+        ruleset: string | null;
+        ai_context_json: string | null;
+        ai_context_markdown: string | null;
+        report: string;
+    };
+};
+export type RunDatasetContractOptions = {
+    type: string | undefined;
+    include?: string | string[] | undefined;
+    profile?: string | undefined;
+    outDir: string | null | undefined;
+    mode: DatasetContractMode;
+    now?: Date;
+    sdkModule?: Record<string, unknown>;
+    runtimeAssetsRoot?: string;
+};
+type ContractPack = {
+    manifest: unknown;
+    schemaText?: string;
+    methodologyText?: string;
+    runtimeRuleset?: unknown;
+    aiContext?: unknown;
+};
+type CanonicalKind = 'contact' | 'flow' | 'flowproperty' | 'lciamethod' | 'lifecyclemodel' | 'process' | 'source' | 'unitgroup';
+export declare function runDatasetContract(options: RunDatasetContractOptions): Promise<DatasetContractReport>;
+declare function normalizeType(value: string | undefined): CanonicalKind;
+declare function normalizeIncludes(value: string | string[] | undefined): DatasetContractInclude[];
+declare function normalizeProfile(value: string): DatasetContractProfile;
+declare function loadFallbackContractPack(options: {
+    type: CanonicalKind;
+    includes: DatasetContractInclude[];
+    profile: DatasetContractProfile;
+    includeAiContext: boolean;
+    runtimeAssetsRoot?: string;
+}): ContractPack;
+declare function resolveSdkRuntimeAssetsRoot(candidatesOverride?: string[], sdkEntryOverride?: string): string;
+declare function resolveCliRepoRoot(candidatesOverride?: string[]): string;
+declare function filterRuntimeRuleset(source: Record<string, unknown>, type: CanonicalKind): unknown | undefined;
+declare function artifactManifest(name: string, content: string): {
+    name: string;
+    sha256: string;
+    bytes: number;
+};
+declare function buildAiContext(options: {
+    type: CanonicalKind;
+    profile: DatasetContractProfile;
+    schemaText?: string;
+    methodologyText?: string;
+    runtimeRuleset?: unknown;
+}): unknown;
+declare function renderAiContextMarkdown(type: CanonicalKind, pack: ContractPack): string;
+export declare const __testInternals: {
+    artifactManifest: typeof artifactManifest;
+    buildAiContext: typeof buildAiContext;
+    filterRuntimeRuleset: typeof filterRuntimeRuleset;
+    loadFallbackContractPack: typeof loadFallbackContractPack;
+    renderAiContextMarkdown: typeof renderAiContextMarkdown;
+    resolveCliRepoRoot: typeof resolveCliRepoRoot;
+    resolveSdkRuntimeAssetsRoot: typeof resolveSdkRuntimeAssetsRoot;
+    normalizeIncludes: typeof normalizeIncludes;
+    normalizeProfile: typeof normalizeProfile;
+    normalizeType: typeof normalizeType;
+};
+export {};