@liuhange/dsh-data-asset-valuation 3.0.0

package/lib/__tests__/valuation.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { calculateCostBasedValue } from '../costBasedValuation.js';
+import { calculateIncomeBasedValue } from '../incomeBasedValuation.js';
+describe('costBasedValuation', () => {
+    const config = {
+        costCategories: ['acquisition', 'processing', 'storage', 'maintenance', 'labor', 'infrastructure'],
+        depreciationYears: 5,
+        depreciationMethod: 'straight-line',
+    };
+    it('正确汇总各类成本', () => {
+        const result = calculateCostBasedValue([
+            { category: 'acquisition', amount: 100000, year: 2024 },
+            { category: 'processing', amount: 50000, year: 2024 },
+            { category: 'storage', amount: 20000, year: 2024 },
+        ], config);
+        expect(result.totalCost).toBe(170000);
+        expect(result.breakdown.acquisition).toBe(100000);
+        expect(result.breakdown.processing).toBe(50000);
+        expect(result.breakdown.storage).toBe(20000);
+    });
+    it('直线折旧法正确计算折旧后价值', () => {
+        const result = calculateCostBasedValue([
+            { category: 'acquisition', amount: 100000, year: 2024 },
+        ], config);
+        expect(result.annualDepreciation).toBe(20000);
+        expect(result.depreciatedValue).toBe(80000);
+    });
+    it('忽略不在costCategories中的类别', () => {
+        const result = calculateCostBasedValue([
+            { category: 'unknown', amount: 999999, year: 2024 },
+        ], config);
+        expect(result.totalCost).toBe(0);
+    });
+});
+describe('incomeBasedValuation', () => {
+    const config = {
+        defaultDiscountRate: 0.08,
+        defaultScenarioYears: 3,
+        scenarioTemplates: ['direct_sale', 'subscription'],
+    };
+    it('DCF正确计算现值', () => {
+        const result = calculateIncomeBasedValue([
+            { type: 'subscription', annualRevenue: 100000, annualCost: 20000, years: 3 },
+        ], config);
+        expect(result.scenarios).toHaveLength(1);
+        expect(result.scenarios[0].netCashFlow).toBe(80000);
+        expect(result.presentValue).toBeGreaterThan(0);
+        expect(result.discountRate).toBe(0.08);
+    });
+    it('多场景现值累加', () => {
+        const result = calculateIncomeBasedValue([
+            { type: 'direct_sale', annualRevenue: 50000, annualCost: 10000, years: 2 },
+            { type: 'subscription', annualRevenue: 30000, annualCost: 5000, years: 3 },
+        ], config);
+        expect(result.scenarios).toHaveLength(2);
+        expect(result.presentValue).toBeGreaterThan(0);
+    });
+    it('自定义折现率生效', () => {
+        const result = calculateIncomeBasedValue([
+            { type: 'direct_sale', annualRevenue: 100000, annualCost: 0, years: 1 },
+        ], config, 0.1);
+        expect(result.discountRate).toBe(0.1);
+        expect(result.scenarios[0].presentValue).toBeCloseTo(90909.09, -1);
+    });
+});
+//# sourceMappingURL=valuation.test.js.map

package/lib/costBasedValuation.js

@@ -0,0 +1,34 @@
+export function calculateCostBasedValue(costItems, config) {
+    const breakdown = {};
+    for (const category of config.costCategories) {
+        breakdown[category] = 0;
+    }
+    let totalCost = 0;
+    for (const item of costItems) {
+        if (!config.costCategories.includes(item.category)) {
+            continue;
+        }
+        breakdown[item.category] = (breakdown[item.category] ?? 0) + item.amount;
+        totalCost += item.amount;
+    }
+    const depreciationYears = config.depreciationYears;
+    let depreciatedValue;
+    let annualDepreciation;
+    if (config.depreciationMethod === 'straight-line') {
+        annualDepreciation = totalCost / depreciationYears;
+        depreciatedValue = totalCost - annualDepreciation;
+    }
+    else {
+        annualDepreciation = (totalCost * 2) / depreciationYears;
+        depreciatedValue = totalCost - annualDepreciation;
+    }
+    if (depreciatedValue < 0)
+        depreciatedValue = 0;
+    return {
+        totalCost: Math.round(totalCost * 100) / 100,
+        depreciatedValue: Math.round(depreciatedValue * 100) / 100,
+        breakdown,
+        annualDepreciation: Math.round(annualDepreciation * 100) / 100,
+    };
+}
+//# sourceMappingURL=costBasedValuation.js.map

package/lib/incomeBasedValuation.js

@@ -0,0 +1,25 @@
+export function calculateIncomeBasedValue(scenarios, config, customDiscountRate) {
+    const discountRate = customDiscountRate ?? config.defaultDiscountRate;
+    const scenarioResults = [];
+    let totalPresentValue = 0;
+    for (const scenario of scenarios) {
+        const years = scenario.years > 0 ? scenario.years : config.defaultScenarioYears;
+        const netCashFlow = scenario.annualRevenue - scenario.annualCost;
+        let pv = 0;
+        for (let year = 1; year <= years; year++) {
+            pv += netCashFlow / Math.pow(1 + discountRate, year);
+        }
+        scenarioResults.push({
+            type: scenario.type,
+            netCashFlow: Math.round(netCashFlow * 100) / 100,
+            presentValue: Math.round(pv * 100) / 100,
+        });
+        totalPresentValue += pv;
+    }
+    return {
+        presentValue: Math.round(totalPresentValue * 100) / 100,
+        scenarios: scenarioResults,
+        discountRate,
+    };
+}
+//# sourceMappingURL=incomeBasedValuation.js.map

package/lib/index.js

@@ -0,0 +1,87 @@
+import { calculateCostBasedValue } from './costBasedValuation.js';
+import { calculateIncomeBasedValue } from './incomeBasedValuation.js';
+import { generateValuationReport } from './valuationReportGenerator.js';
+import { validateValuationArgs } from './invariant.js';
+export const name = '@liuhange/dsh-data-asset-valuation';
+export const inject = ['tools'];
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'value_data_asset',
+        description: '数据资产估值：成本法（重置成本-折旧）+ 收益法（DCF折现）双模型，输出建议估值与定价区间',
+        parameters: {
+            type: 'object',
+            properties: {
+                assetName: { type: 'string', description: '数据资产名称' },
+                costItems: {
+                    type: 'array',
+                    description: '成本明细列表',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            category: { type: 'string', description: '成本类别(acquisition/processing/storage/maintenance/labor/infrastructure)' },
+                            amount: { type: 'number', description: '金额(元)' },
+                            year: { type: 'number', description: '年份' },
+                        },
+                    },
+                },
+                incomeScenarios: {
+                    type: 'array',
+                    description: '收益场景列表',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: '场景类型(direct_sale/subscription/api_call/data_sharing/analytics_service)' },
+                            annualRevenue: { type: 'number', description: '年收益(元)' },
+                            annualCost: { type: 'number', description: '年成本(元)' },
+                            years: { type: 'number', description: '持续年限' },
+                        },
+                    },
+                },
+                discountRate: { type: 'number', description: '自定义折现率（可选，默认从配置读取）' },
+                qualityScore: { type: 'number', description: '质量评分（可选，影响价值等级判定）' },
+            },
+            required: ['assetName', 'costItems', 'incomeScenarios'],
+        },
+        async execute(args) {
+            try {
+                const validated = validateValuationArgs(args);
+                const { readFileSync } = await import('node:fs');
+                let rulesConfig;
+                try {
+                    rulesConfig = JSON.parse(readFileSync(process.env.BUSINESS_RULES_PATH || 'config/business-rules.json', 'utf-8'));
+                }
+                catch {
+                    return JSON.stringify({ error: 'VALUATION_RULES_MISSING', message: '无法加载business-rules.json' });
+                }
+                const valuationConfig = rulesConfig.valuation;
+                if (!valuationConfig) {
+                    return JSON.stringify({ error: 'VALUATION_RULES_MISSING', message: 'valuation配置段缺失' });
+                }
+                let policyDocuments;
+                try {
+                    const policyConfig = JSON.parse(readFileSync(process.env.POLICY_REFS_PATH || 'config/policy-references.json', 'utf-8'));
+                    const stage = policyConfig.policyReferences?.find((s) => s.stage === 'VALUATION');
+                    policyDocuments = stage?.documents ?? [];
+                }
+                catch {
+                    policyDocuments = [];
+                }
+                if (!policyDocuments || policyDocuments.length === 0) {
+                    return JSON.stringify({ error: 'POLICY_REFERENCES_EMPTY', message: 'VALUATION阶段政策依据缺失' });
+                }
+                const costBased = calculateCostBasedValue(validated.costItems, valuationConfig.costBased);
+                const incomeBased = calculateIncomeBasedValue(validated.incomeScenarios, valuationConfig.incomeBased, validated.discountRate);
+                const report = generateValuationReport(validated.assetName, costBased, incomeBased, valuationConfig.pricingReference, validated.qualityScore, policyDocuments);
+                return JSON.stringify(report, null, 2);
+            }
+            catch (e) {
+                const err = e;
+                return JSON.stringify({
+                    error: err.message.split(':')[0] ?? 'UNKNOWN_ERROR',
+                    message: err.message,
+                });
+            }
+        },
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/invariant.js

@@ -0,0 +1,48 @@
+export function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(`INVARIANT_VIOLATION: ${message}`);
+    }
+}
+export function validateValuationArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('INVALID_ARGS: args must be an object');
+    }
+    if (!args.assetName || typeof args.assetName !== 'string') {
+        throw new Error('INVALID_ARGS: assetName is required and must be a string');
+    }
+    if (!Array.isArray(args.costItems)) {
+        throw new Error('INVALID_ARGS: costItems is required and must be an array');
+    }
+    for (const item of args.costItems) {
+        if (typeof item.category !== 'string' || typeof item.amount !== 'number' || typeof item.year !== 'number') {
+            throw new Error('INVALID_ARGS: each costItem must have category(string), amount(number), year(number)');
+        }
+        if (item.amount < 0) {
+            throw new Error(`INVALID_ARGS: cost amount cannot be negative for category "${item.category}"`);
+        }
+    }
+    if (!Array.isArray(args.incomeScenarios)) {
+        throw new Error('INVALID_ARGS: incomeScenarios is required and must be an array');
+    }
+    for (const scenario of args.incomeScenarios) {
+        if (typeof scenario.type !== 'string' || typeof scenario.annualRevenue !== 'number' || typeof scenario.annualCost !== 'number') {
+            throw new Error('INVALID_ARGS: each incomeScenario must have type(string), annualRevenue(number), annualCost(number)');
+        }
+        if (scenario.annualRevenue < 0 || scenario.annualCost < 0) {
+            throw new Error(`INVALID_ARGS: revenue/cost cannot be negative for scenario "${scenario.type}"`);
+        }
+    }
+    const result = {
+        assetName: args.assetName,
+        costItems: args.costItems,
+        incomeScenarios: args.incomeScenarios,
+    };
+    if (typeof args.discountRate === 'number') {
+        result.discountRate = args.discountRate;
+    }
+    if (typeof args.qualityScore === 'number') {
+        result.qualityScore = args.qualityScore;
+    }
+    return result;
+}
+//# sourceMappingURL=invariant.js.map

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/valuationReportGenerator.js

@@ -0,0 +1,38 @@
+export function generateValuationReport(assetName, costBased, incomeBased, pricingConfig, qualityScore, policyDocuments) {
+    const recommendedValue = Math.round((costBased.depreciatedValue * 0.4 + incomeBased.presentValue * 0.6) * 100) / 100;
+    const thresholds = pricingConfig.valueLevelThresholds;
+    let valueLevel;
+    const effectiveScore = qualityScore ?? 60;
+    if (effectiveScore >= thresholds.high) {
+        valueLevel = 'high';
+    }
+    else if (effectiveScore >= thresholds.medium) {
+        valueLevel = 'medium';
+    }
+    else {
+        valueLevel = 'low';
+    }
+    const pricingSuggestion = buildPricingSuggestion(recommendedValue, valueLevel, costBased, incomeBased);
+    return {
+        assetName,
+        costBased,
+        incomeBased,
+        recommendedValue,
+        pricingSuggestion,
+        valueLevel,
+        policyReferences: policyDocuments,
+        timestamp: new Date().toISOString(),
+    };
+}
+function buildPricingSuggestion(recommended, level, costBased, incomeBased) {
+    const levelLabel = level === 'high' ? '高价值' : level === 'medium' ? '中价值' : '低价值';
+    const parts = [];
+    parts.push(`建议估值: ${recommended} 元（${levelLabel}）`);
+    parts.push(`成本法估值: ${costBased.depreciatedValue} 元（折旧后）`);
+    parts.push(`收益法估值: ${incomeBased.presentValue} 元（折现率${(incomeBased.discountRate * 100).toFixed(1)}%）`);
+    if (recommended > 0) {
+        parts.push(`定价区间: ${Math.round(recommended * 0.8)} ~ ${Math.round(recommended * 1.2)} 元`);
+    }
+    return parts.join('；');
+}
+//# sourceMappingURL=valuationReportGenerator.js.map

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@liuhange/dsh-data-asset-valuation",
+  "description": "Data asset valuation plugin: cost-based (replacement cost - depreciation) + income-based (DCF) dual model",
+  "version": "3.0.0",
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "git+https://github.com/liuhange789/data-asset-inspector.git", "directory": "packages/data-asset/data-asset-valuation" },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": { "types": "./lib/types/index.d.ts", "default": "./lib/index.js" },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": ["lib/**/*.js", "lib/types/**/*.d.ts"],
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.0",
+    "@deepseek-ai/dsh-tools": "0.0.1-rc.1",
+    "@liuhange/dsh-data-asset-shared": "^3.0.0"
+  },
+  "dsh": { "bundle": { "patch": true } }
+}