@liuhange/dsh-data-asset-shared 1.0.0

package/README.md

@@ -0,0 +1,25 @@
+# @deepseek-ai/dsh-data-asset-shared
+
+Shared infrastructure for data assetization plugins.
+
+## Modules
+
+- **BusinessRulesLoader**: Loads `config/business-rules.json` with 5-level config degradation (CONFIG_LOADED / DEFAULT_MISSING / DEFAULT_PARSE / DEFAULT_VERSION / DEFAULT_PARTIAL)
+- **FileFormatAdapter**: Reads/writes CSV, JSON, TXT, XLSX formats with unknown-format degradation to TXT
+- **ReportGenerator**: Generates masking, cleaning, inventory, and packaging reports per spec 6.3-6.6
+- **PathValidator**: Validates file paths against working directory, prevents path traversal attacks
+- **AuditLogger**: Logs processing operations with `[pluginName] message` format
+
+## Usage
+
+```typescript
+import { BusinessRulesLoader, FileFormatAdapter, ReportGenerator, PathValidator, AuditLogger } from '@deepseek-ai/dsh-data-asset-shared'
+
+const loader = new BusinessRulesLoader()
+const { config, status } = loader.load()
+```
+
+## Known Limitations and Deferred Work
+
+- XLSX format support is limited to text-based line reading; full binary XLSX parsing requires the `xlsx` library
+- Large file streaming (>10MB) is detected but not yet implemented with stream APIs

package/lib/index.js

@@ -0,0 +1,415 @@
+import * as fs from "fs";
+import * as path from "path";
+//#region lib/types/defaultBusinessRules.js
+const defaultBusinessRules = {
+	version: "1.0",
+	lastUpdated: "2026-08-17",
+	valueAssessment: {
+		highValue: {
+			keywords: [
+				"供应链",
+				"销售明细",
+				"设备工况",
+				"交易流水"
+			],
+			score: 5,
+			label: "★★★★★",
+			recommendation: "优先交易，建议入表"
+		},
+		mediumValue: {
+			keywords: [
+				"用户行为",
+				"产品数据",
+				"行业报告"
+			],
+			score: 3,
+			label: "★★★",
+			recommendation: "脱敏后交易"
+		},
+		lowValue: {
+			keywords: [
+				"日志",
+				"备份",
+				"临时"
+			],
+			score: 1,
+			label: "★",
+			recommendation: "评估处理成本"
+		},
+		defaultValue: {
+			score: 3,
+			label: "★★★",
+			recommendation: "需进一步评估"
+		}
+	},
+	sensitivePatterns: {
+		idCard: {
+			pattern: "[1-9]\\d{5}(18|19|20)?\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]",
+			level: "FULL"
+		},
+		phone: {
+			pattern: "1[3-9]\\d{9}",
+			level: "PARTIAL"
+		},
+		bankCard: {
+			pattern: "[1-9]\\d{15,18}",
+			level: "PARTIAL"
+		},
+		email: {
+			pattern: "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}",
+			level: "PARTIAL"
+		}
+	},
+	maskingLevels: {
+		FULL: {
+			description: "完全匿名化",
+			applyTo: ["idCard"]
+		},
+		PARTIAL: {
+			description: "假名化，保留前3后4",
+			applyTo: ["phone", "bankCard"]
+		},
+		GENERALIZE: {
+			description: "泛化处理",
+			applyTo: ["email"]
+		}
+	},
+	cleaningRules: {
+		missingValueStrategy: {
+			government: "interpolation",
+			financial: "manual_review",
+			behavior: "mode_fill"
+		},
+		qualityThreshold: {
+			A: {
+				missingRate: .05,
+				errorRate: .01,
+				label: "优秀"
+			},
+			B: {
+				missingRate: .1,
+				errorRate: .03,
+				label: "良好"
+			},
+			C: {
+				missingRate: .2,
+				errorRate: .05,
+				label: "合格"
+			},
+			D: {
+				missingRate: .2,
+				errorRate: .05,
+				label: "不合格",
+				action: "不建议交易"
+			}
+		}
+	},
+	compliance: { policies: [
+		{
+			name: "数据产权登记工作指引",
+			doc: "国数综政策〔2026〕35号",
+			check: "数据来源可登记"
+		},
+		{
+			name: "数据流通安全治理",
+			doc: "发改数据〔2025〕18号",
+			check: "来源合法性"
+		},
+		{
+			name: "数据脱敏工具标准",
+			doc: "YD/T 6225-2024",
+			check: "脱敏效果达标"
+		}
+	] },
+	packaging: {
+		complianceStatements: [
+			"本数据产品已完成脱敏处理",
+			"不包含个人身份信息",
+			"数据来源合法",
+			"建议交易前完成数据产权登记"
+		],
+		pricingRules: [
+			{
+				valueLevel: "★★★★★",
+				suggestion: "根据数据质量、稀缺性和应用场景综合定价，建议高价交易"
+			},
+			{
+				valueLevel: "★★★★",
+				suggestion: "根据数据质量和应用场景定价，建议中高价交易"
+			},
+			{
+				valueLevel: "★★★",
+				suggestion: "根据数据质量和应用场景综合定价"
+			},
+			{
+				valueLevel: "★★",
+				suggestion: "建议低价交易或内部使用"
+			},
+			{
+				valueLevel: "★",
+				suggestion: "建议评估处理成本后决定是否交易"
+			}
+		],
+		defaultDescription: "适用于数据分析、模型训练、行业研究等场景",
+		version: "V1.0"
+	}
+};
+//#endregion
+//#region lib/types/businessRulesLoader.js
+var BusinessRulesLoader = class {
+	cachedResult = null;
+	configPath;
+	constructor(configPath) {
+		this.configPath = configPath ? path.resolve(configPath) : path.resolve(process.cwd(), "config", "business-rules.json");
+	}
+	load() {
+		if (this.cachedResult) return this.cachedResult;
+		const result = this.loadInternal();
+		this.cachedResult = result;
+		return result;
+	}
+	loadInternal() {
+		if (!fs.existsSync(this.configPath)) return this.createDefaultResult("DEFAULT_MISSING");
+		let raw;
+		try {
+			raw = fs.readFileSync(this.configPath, "utf-8");
+		} catch {
+			return this.createDefaultResult("DEFAULT_PARSE");
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return this.createDefaultResult("DEFAULT_PARSE");
+		}
+		if (!this.isBusinessRulesConfig(parsed)) return this.createDefaultResult("DEFAULT_PARSE");
+		if (!this.isVersionCompatible(parsed.version)) return this.createDefaultResult("DEFAULT_VERSION");
+		if (!this.hasRequiredNodes(parsed)) return this.createDefaultResult("DEFAULT_PARTIAL");
+		return {
+			config: parsed,
+			status: "CONFIG_LOADED"
+		};
+	}
+	createDefaultResult(status) {
+		return {
+			config: defaultBusinessRules,
+			status
+		};
+	}
+	isBusinessRulesConfig(value) {
+		return typeof value === "object" && value !== null && "version" in value && "valueAssessment" in value && "sensitivePatterns" in value && "cleaningRules" in value && "compliance" in value && "packaging" in value;
+	}
+	isVersionCompatible(version) {
+		if (typeof version !== "string") return false;
+		return version.startsWith("1.");
+	}
+	hasRequiredNodes(config) {
+		return config.valueAssessment !== void 0 && config.sensitivePatterns !== void 0 && config.maskingLevels !== void 0 && config.cleaningRules !== void 0 && config.compliance !== void 0 && config.packaging !== void 0;
+	}
+	clearCache() {
+		this.cachedResult = null;
+	}
+};
+//#endregion
+//#region lib/types/fileFormatAdapter.js
+var FileFormatAdapter = class {
+	detectFormat(filePath) {
+		const ext = path.extname(filePath).toLowerCase().slice(1);
+		if (ext === "csv" || ext === "json" || ext === "txt" || ext === "xlsx") return ext;
+		return "unknown";
+	}
+	async read(filePath) {
+		const format = this.detectFormat(filePath);
+		const fullPath = path.resolve(filePath);
+		if (!fs.existsSync(fullPath)) throw new Error(`错误：文件不存在 - ${fullPath}`);
+		const isLargeFile = fs.statSync(fullPath).size >= 10 * 1024 * 1024;
+		switch (format) {
+			case "csv": return this.readCsv(fullPath);
+			case "json": return this.readJson(fullPath);
+			case "xlsx": return this.readXlsx(fullPath);
+			default: return this.readTxt(fullPath, format, isLargeFile);
+		}
+	}
+	async write(filePath, lines, format) {
+		const fullPath = path.resolve(filePath);
+		const dir = path.dirname(fullPath);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		switch (format) {
+			case "csv":
+				this.writeCsv(fullPath, lines);
+				break;
+			case "json":
+				this.writeJson(fullPath, lines);
+				break;
+			case "xlsx":
+				this.writeXlsx(fullPath, lines);
+				break;
+			default:
+				fs.writeFileSync(fullPath, lines.join("\n"), "utf-8");
+				break;
+		}
+	}
+	readTxt(filePath, format, _isLargeFile) {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return {
+			lines: content.split("\n").filter((line) => line.trim()),
+			format,
+			raw: content
+		};
+	}
+	readCsv(filePath) {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return {
+			lines: content.split("\n").filter((line) => line.trim()),
+			format: "csv",
+			raw: content
+		};
+	}
+	readJson(filePath) {
+		const content = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (Array.isArray(parsed)) return {
+			lines: parsed.map((item) => JSON.stringify(item)),
+			format: "json",
+			raw: parsed
+		};
+		return {
+			lines: [JSON.stringify(parsed)],
+			format: "json",
+			raw: parsed
+		};
+	}
+	readXlsx(filePath) {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return {
+			lines: content.split("\n").filter((line) => line.trim()),
+			format: "xlsx",
+			raw: content
+		};
+	}
+	writeCsv(filePath, lines) {
+		fs.writeFileSync(filePath, lines.join("\n"), "utf-8");
+	}
+	writeJson(filePath, lines) {
+		const objects = lines.map((line) => {
+			try {
+				return JSON.parse(line);
+			} catch {
+				return line;
+			}
+		});
+		fs.writeFileSync(filePath, JSON.stringify(objects, null, 2), "utf-8");
+	}
+	writeXlsx(filePath, lines) {
+		fs.writeFileSync(filePath, lines.join("\n"), "utf-8");
+	}
+};
+//#endregion
+//#region lib/types/reportGenerator.js
+var ReportGenerator = class {
+	generateMaskingReport(params) {
+		const findingsText = Object.keys(params.fieldTypeCounts).length > 0 ? Object.entries(params.fieldTypeCounts).map(([type, count]) => `发现 ${count} 个${type}类型的敏感数据`).join("；") : "无";
+		return `【脱敏报告】
+- 处理文件：${params.inputPath}
+- 发现敏感字段：${findingsText}
+- 脱敏策略：${params.strategy}
+- 输出文件：${params.outputPath}
+- 状态：✅ 完成`;
+	}
+	generateCleaningReport(params) {
+		let report = `【数据清洗报告】
+- 文件：${params.inputPath}
+- 原始行数：${params.originalLineCount}
+- 去重后行数：${params.originalLineCount - params.duplicateRemoved}（删除 ${params.duplicateRemoved} 行重复）
+`;
+		if (params.standardizeApplied) report += `- 格式标准化：✅ 完成\n`;
+		report += `- 异常值检测：发现 ${params.anomalyTotalCount} 个异常\n`;
+		if (params.anomalies.length > 0) {
+			const anomalyText = params.anomalies.slice(0, 5).map((a) => `行${a.line}: ${a.reason}`).join("；");
+			report += `  异常详情：${anomalyText}`;
+			if (params.anomalyTotalCount > 5) report += `...等${params.anomalyTotalCount}项`;
+			report += `\n`;
+		}
+		report += `- 输出文件：${params.outputPath}\n- 状态：✅ 完成`;
+		return report;
+	}
+	generateInventoryReport(params) {
+		let report = `【数据资产盘点报告】\n- 目录：${params.directory}\n- 发现数据文件：${params.fileCount} 个\n\n`;
+		report += `| 文件名 | 大小 | 类型 | 价值评估 | 说明 |\n`;
+		report += `|--------|------|------|----------|------|\n`;
+		for (const item of params.assetItems) report += `| ${item.fileName} | ${item.size} | ${item.type} | ${item.valueAssessment} | ${item.description} |\n`;
+		report += `\n---\n【建议】\n`;
+		report += `1. 高价值数据（★★★★★）建议优先进行清洗和脱敏后交易\n`;
+		report += `2. 低价值数据建议评估是否值得投入处理成本\n`;
+		report += `3. 所有数据交易前必须完成合规审查\n`;
+		return report;
+	}
+	generatePackagingManual(params) {
+		const manual = params.productManual;
+		const complianceText = manual.complianceStatements.map((stmt) => `✅ ${stmt}`).join("\n");
+		return `========================================
+        数据产品说明书
+========================================
+
+【产品名称】${manual.productName}
+【版本】${manual.version}
+【生成日期】${manual.generatedDate}
+
+【数据概览】
+- 源文件：${manual.dataOverview.sourceFile}
+- 数据量：${manual.dataOverview.recordCount} 条记录
+- 文件大小：${manual.dataOverview.fileSizeKb.toFixed(1)} KB
+- 格式：${manual.dataOverview.format}
+
+【数据样例】（前5行）
+${manual.sampleLines.join("\n")}
+
+【使用场景】
+${manual.usageScenario}
+
+【合规声明】
+${complianceText}
+
+【定价建议】
+${manual.pricingSuggestion}
+
+--- 本产品由数据资产化工具包自动生成 ---`;
+	}
+};
+//#endregion
+//#region lib/types/pathValidator.js
+var PathValidator = class {
+	validate(filePath, workingDir) {
+		const resolved = path.resolve(filePath);
+		if (filePath.includes("..")) throw new Error(`错误：路径不合法 - ${filePath}`);
+		const relative = path.relative(workingDir, resolved);
+		if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`错误：路径不合法 - ${filePath}`);
+		return resolved;
+	}
+	validateDirectory(dirPath, workingDir) {
+		return this.validate(dirPath, workingDir);
+	}
+};
+//#endregion
+//#region lib/types/auditLogger.js
+var AuditLogger = class {
+	logDir;
+	constructor(logDir) {
+		this.logDir = logDir ?? path.resolve(process.cwd(), "logs");
+	}
+	log(params) {
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const operator = params.operator ?? "system";
+		const logLine = `[${params.pluginName}] ${timestamp} | 操作: ${params.operation} | 操作人: ${operator} | 输入: ${params.inputPath} | 输出: ${params.outputPath} | 结果: ${params.result}`;
+		console.log(logLine);
+		if (params.writeToFile) this.writeToFile(logLine);
+	}
+	writeToFile(logLine) {
+		if (!fs.existsSync(this.logDir)) fs.mkdirSync(this.logDir, { recursive: true });
+		const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+		const logFile = path.join(this.logDir, `audit-${date}.log`);
+		fs.appendFileSync(logFile, logLine + "\n", "utf-8");
+	}
+};
+//#endregion
+export { AuditLogger, BusinessRulesLoader, FileFormatAdapter, PathValidator, ReportGenerator, defaultBusinessRules };

package/lib/invariant.js

@@ -0,0 +1,5 @@
+//#region lib/types/invariant.js
+const invariant = "data-asset-shared";
+function install() {}
+//#endregion
+export { install, invariant };

package/lib/types/auditLogger.d.ts

@@ -0,0 +1,16 @@
+export interface AuditLogParams {
+    pluginName: string;
+    operation: string;
+    inputPath: string;
+    outputPath: string;
+    result: string;
+    operator?: string;
+    writeToFile?: boolean;
+}
+export declare class AuditLogger {
+    private readonly logDir;
+    constructor(logDir?: string);
+    log(params: AuditLogParams): void;
+    private writeToFile;
+}
+//# sourceMappingURL=auditLogger.d.ts.map

package/lib/types/businessRulesLoader.d.ts

@@ -0,0 +1,14 @@
+import type { BusinessRulesLoadResult } from './types.js';
+export declare class BusinessRulesLoader {
+    private cachedResult;
+    private readonly configPath;
+    constructor(configPath?: string);
+    load(): BusinessRulesLoadResult;
+    private loadInternal;
+    private createDefaultResult;
+    private isBusinessRulesConfig;
+    private isVersionCompatible;
+    private hasRequiredNodes;
+    clearCache(): void;
+}
+//# sourceMappingURL=businessRulesLoader.d.ts.map

package/lib/types/defaultBusinessRules.d.ts

@@ -0,0 +1,3 @@
+import type { BusinessRulesConfig } from './types.js';
+export declare const defaultBusinessRules: BusinessRulesConfig;
+//# sourceMappingURL=defaultBusinessRules.d.ts.map

package/lib/types/fileFormatAdapter.d.ts

@@ -0,0 +1,19 @@
+import type { DataFormat } from './types.js';
+export interface FileReadResult {
+    lines: string[];
+    format: DataFormat;
+    raw: unknown;
+}
+export declare class FileFormatAdapter {
+    detectFormat(filePath: string): DataFormat;
+    read(filePath: string): Promise<FileReadResult>;
+    write(filePath: string, lines: string[], format: DataFormat): Promise<void>;
+    private readTxt;
+    private readCsv;
+    private readJson;
+    private readXlsx;
+    private writeCsv;
+    private writeJson;
+    private writeXlsx;
+}
+//# sourceMappingURL=fileFormatAdapter.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types.js';
+export { defaultBusinessRules } from './defaultBusinessRules.js';
+export { BusinessRulesLoader } from './businessRulesLoader.js';
+export { FileFormatAdapter } from './fileFormatAdapter.js';
+export type { FileReadResult } from './fileFormatAdapter.js';
+export { ReportGenerator } from './reportGenerator.js';
+export type { MaskingReportParams, CleaningReportParams, InventoryReportParams, PackagingManualParams, } from './reportGenerator.js';
+export { PathValidator } from './pathValidator.js';
+export { AuditLogger } from './auditLogger.js';
+export type { AuditLogParams } from './auditLogger.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,3 @@
+export declare const invariant = "data-asset-shared";
+export declare function install(): void;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/pathValidator.d.ts

@@ -0,0 +1,5 @@
+export declare class PathValidator {
+    validate(filePath: string, workingDir: string): string;
+    validateDirectory(dirPath: string, workingDir: string): string;
+}
+//# sourceMappingURL=pathValidator.d.ts.map

package/lib/types/reportGenerator.d.ts

@@ -0,0 +1,35 @@
+import type { SensitiveField, AssetItem, ProductManual } from './types.js';
+export interface MaskingReportParams {
+    inputPath: string;
+    outputPath: string;
+    strategy: string;
+    findings: SensitiveField[];
+    fieldTypeCounts: Record<string, number>;
+}
+export interface CleaningReportParams {
+    inputPath: string;
+    outputPath: string;
+    originalLineCount: number;
+    duplicateRemoved: number;
+    standardizeApplied: boolean;
+    anomalies: Array<{
+        line: number;
+        reason: string;
+    }>;
+    anomalyTotalCount: number;
+}
+export interface InventoryReportParams {
+    directory: string;
+    fileCount: number;
+    assetItems: AssetItem[];
+}
+export interface PackagingManualParams {
+    productManual: ProductManual;
+}
+export declare class ReportGenerator {
+    generateMaskingReport(params: MaskingReportParams): string;
+    generateCleaningReport(params: CleaningReportParams): string;
+    generateInventoryReport(params: InventoryReportParams): string;
+    generatePackagingManual(params: PackagingManualParams): string;
+}
+//# sourceMappingURL=reportGenerator.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,135 @@
+export type SensitiveFieldType = 'idCard' | 'phone' | 'bankCard' | 'email';
+export type MaskingStrategy = 'FULL' | 'PARTIAL' | 'GENERALIZE';
+export type DataFormat = 'csv' | 'json' | 'txt' | 'xlsx' | 'unknown';
+export type ProcessingStatus = 'SUCCESS' | 'FAILED' | 'SKIPPED';
+export type ConfigStatus = 'CONFIG_LOADED' | 'DEFAULT_MISSING' | 'DEFAULT_PARSE' | 'DEFAULT_VERSION' | 'DEFAULT_PARTIAL';
+export interface ValueRule {
+    keywords: string[];
+    score: number;
+    label: string;
+    recommendation: string;
+}
+export interface DefaultValueRule {
+    score: number;
+    label: string;
+    recommendation: string;
+}
+export interface ValueAssessmentRules {
+    highValue: ValueRule;
+    mediumValue: ValueRule;
+    lowValue: ValueRule;
+    defaultValue: DefaultValueRule;
+}
+export interface SensitivePattern {
+    pattern: string;
+    level: MaskingStrategy;
+}
+export interface SensitivePatterns {
+    idCard: SensitivePattern;
+    phone: SensitivePattern;
+    bankCard: SensitivePattern;
+    email: SensitivePattern;
+}
+export interface MaskingLevelConfig {
+    description: string;
+    applyTo: SensitiveFieldType[];
+}
+export interface MaskingLevels {
+    FULL: MaskingLevelConfig;
+    PARTIAL: MaskingLevelConfig;
+    GENERALIZE: MaskingLevelConfig;
+}
+export interface CleaningRules {
+    missingValueStrategy: Record<string, string>;
+    qualityThreshold: Record<string, QualityThreshold>;
+}
+export interface QualityThreshold {
+    missingRate: number;
+    errorRate: number;
+    label: string;
+    action?: string;
+}
+export interface CompliancePolicy {
+    name: string;
+    doc: string;
+    check: string;
+}
+export interface ComplianceConfig {
+    policies: CompliancePolicy[];
+}
+export interface PricingRule {
+    valueLevel: string;
+    suggestion: string;
+}
+export interface PackagingRules {
+    complianceStatements: string[];
+    pricingRules: PricingRule[];
+    defaultDescription: string;
+    version: string;
+}
+export interface BusinessRulesConfig {
+    version: string;
+    lastUpdated: string;
+    valueAssessment: ValueAssessmentRules;
+    sensitivePatterns: SensitivePatterns;
+    maskingLevels: MaskingLevels;
+    cleaningRules: CleaningRules;
+    compliance: ComplianceConfig;
+    packaging: PackagingRules;
+}
+export interface SensitiveField {
+    type: SensitiveFieldType;
+    value: string;
+    line: number;
+    column: number;
+}
+export interface DataFile {
+    fileName: string;
+    fullPath: string;
+    size: number;
+    format: DataFormat;
+}
+export interface ProcessingResult {
+    status: ProcessingStatus;
+    inputPath: string;
+    outputPath: string;
+    report: string;
+    error?: string;
+}
+export interface AssetItem {
+    fileName: string;
+    size: string;
+    type: string;
+    valueAssessment: string;
+    description: string;
+}
+export interface DataOverview {
+    sourceFile: string;
+    recordCount: number;
+    fileSizeKb: number;
+    format: string;
+}
+export interface ProductManual {
+    productName: string;
+    version: string;
+    generatedDate: string;
+    dataOverview: DataOverview;
+    sampleLines: string[];
+    usageScenario: string;
+    complianceStatements: string[];
+    pricingSuggestion: string;
+}
+export interface OrchestrationResult {
+    maskingReport: string;
+    cleaningReport: string;
+    inventoryReport: string;
+    packagingManual: string;
+    completedStages: number;
+    failedStage?: string;
+    error?: string;
+}
+export interface BusinessRulesLoadResult {
+    config: BusinessRulesConfig;
+    status: ConfigStatus;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@liuhange/dsh-data-asset-shared",
+  "description": "Shared infrastructure for data assetization plugins: business rules loader, file format adapter, report generator, path validator, audit logger",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/data-asset/data-asset-shared"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "csv-parse": "^5.5.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^0.1.0",
+    "@deepseek-ai/dsh-tools": "^0.1.0",
+    "@deepseek-ai/schemastery": "^0.1.0"
+  }
+}