@gong-ym/ai-spec-auto 0.2.3

package/src/scanner/detectors/springmvc-detector.js

@@ -0,0 +1,46 @@
+class SpringMvcDetector {
+  constructor() {
+    this.name = 'SpringMvcDetector';
+  }
+
+  detect(facts) {
+    const javaText = `${facts.java?.pomXml || ''}\n${facts.java?.gradle || ''}`.toLowerCase();
+    const keyPaths = facts.keyPaths || [];
+    const reasons = [];
+    let confidence = 0;
+
+    if (facts.java?.keywords?.springMvc || javaText.includes('spring-webmvc')) {
+      confidence += 55;
+      reasons.push('检测到 Spring MVC 依赖');
+    }
+    if (javaText.includes('javax.servlet') || javaText.includes('jakarta.servlet')) {
+      confidence += 15;
+      reasons.push('检测到 Servlet 依赖');
+    }
+    if (keyPaths.includes('src/main/java')) {
+      confidence += 10;
+      reasons.push('检测到 Java 源码目录');
+    }
+    if (keyPaths.includes('pom.xml') || keyPaths.includes('build.gradle') || keyPaths.includes('build.gradle.kts')) {
+      confidence += 10;
+      reasons.push('检测到 Java 构建文件');
+    }
+
+    if (confidence < 50) return null;
+
+    return {
+      detector: this.name,
+      framework: 'spring-mvc',
+      language: ['Java'],
+      buildTool: keyPaths.includes('pom.xml') ? 'Maven' : 'Gradle',
+      confidence: Math.min(confidence, 100),
+      tags: ['backend', 'java', 'spring-mvc'],
+      reasons,
+      manifestSlug: 'backend-java-springmvc-standard',
+    };
+  }
+}
+
+module.exports = {
+  SpringMvcDetector,
+};

package/src/scanner/detectors/vue-vite-detector.js

@@ -0,0 +1,52 @@
+function hasDependency(facts, name) {
+  return Boolean(facts.dependencies?.[name] || facts.devDependencies?.[name]);
+}
+
+class VueViteDetector {
+  constructor() {
+    this.name = 'VueViteDetector';
+  }
+
+  detect(facts) {
+    const reasons = [];
+    let confidence = 0;
+
+    if (hasDependency(facts, 'vue')) {
+      confidence += 40;
+      reasons.push('检测到 vue 依赖');
+    }
+    if (hasDependency(facts, 'vite')) {
+      confidence += 25;
+      reasons.push('检测到 vite 依赖');
+    }
+    if (hasDependency(facts, '@vitejs/plugin-vue')) {
+      confidence += 20;
+      reasons.push('检测到 @vitejs/plugin-vue 插件');
+    }
+    if ((facts.keyPaths || []).includes('src/main.ts') || (facts.keyPaths || []).includes('src/main.js')) {
+      confidence += 5;
+      reasons.push('检测到 Vue 常见入口文件');
+    }
+    if ((facts.keyPaths || []).some((item) => item.startsWith('vite.config.'))) {
+      confidence += 5;
+      reasons.push('检测到 vite.config 配置');
+    }
+
+    if (confidence < 40) return null;
+
+    return {
+      detector: this.name,
+      framework: 'vue-vite',
+      language: hasDependency(facts, 'typescript') ? ['TypeScript'] : ['JavaScript'],
+      buildTool: 'Vite',
+      confidence: Math.min(confidence, 100),
+      tags: ['frontend', 'vue', 'vite'],
+      reasons,
+      manifestSlug: 'frontend-vue-vite-standard',
+    };
+  }
+}
+
+module.exports = {
+  VueViteDetector,
+};

package/src/scanner/engine.js

@@ -0,0 +1,72 @@
+const { BoundaryResolver } = require('./boundary/boundary-resolver');
+const { FactExtractor } = require('./facts/fact-extractor');
+const { DetectorRegistry } = require('./detectors/detector-registry');
+
+function mergeDependencyMaps(...maps) {
+  return maps.reduce((acc, item) => {
+    for (const [name, meta] of Object.entries(item || {})) {
+      acc[name] = meta;
+    }
+    return acc;
+  }, {});
+}
+
+function buildPackageResult(facts, detection) {
+  const primary = detection.primary || null;
+  return {
+    packageId: facts.packageId,
+    name: facts.name || undefined,
+    path: facts.relativePath,
+    primary,
+    candidates: detection.candidates,
+    tags: detection.tags,
+    recommendedManifest: primary?.manifestSlug || undefined,
+    confidence: primary?.confidence || 0,
+    reasons: primary?.reasons || [],
+    buildTool: primary?.buildTool || undefined,
+    language: primary?.language || undefined,
+    testTools: facts.testTools || [],
+    componentLibraries: facts.componentLibraries || [],
+    packageManager: facts.packageManager || undefined,
+  };
+}
+
+class TechScannerEngine {
+  constructor(options = {}) {
+    this.boundaryResolver = options.boundaryResolver || new BoundaryResolver();
+    this.factExtractor = options.factExtractor || new FactExtractor();
+    this.detectorRegistry = options.detectorRegistry || new DetectorRegistry();
+  }
+
+  async scan(rootDir, options = {}) {
+    const workspace = this.boundaryResolver.resolve(rootDir, options);
+    const rootFacts = this.factExtractor.extract({
+      rootDir: workspace.rootDir,
+      relativePath: '.',
+      workspaceRoot: workspace.rootDir,
+    });
+    const packages = workspace.packages.map((pkg) => {
+      const facts = this.factExtractor.extract({
+        rootDir: pkg.rootDir,
+        relativePath: pkg.relativePath,
+        workspaceRoot: workspace.rootDir,
+      });
+      const detection = this.detectorRegistry.detect(facts);
+      return buildPackageResult(facts, detection);
+    });
+
+    return {
+      workspace: {
+        rootDir: workspace.rootDir,
+        type: workspace.type,
+        packageManager: workspace.packageManager || rootFacts.packageManager || undefined,
+        rootDependencies: mergeDependencyMaps(rootFacts.dependencies, rootFacts.devDependencies),
+      },
+      packages,
+    };
+  }
+}
+
+module.exports = {
+  TechScannerEngine,
+};

package/src/scanner/facts/fact-extractor.js

@@ -0,0 +1,211 @@
+const fs = require('fs');
+const path = require('path');
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readTextIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return '';
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function addDependencies(target, dependencies, source, overwrite = true) {
+  for (const [name, version] of Object.entries(dependencies || {})) {
+    if (!overwrite && target[name]) continue;
+    if (version && typeof version === 'object' && Object.prototype.hasOwnProperty.call(version, 'version')) {
+      target[name] = { ...version, source: version.source || source };
+      continue;
+    }
+    target[name] = {
+      version: String(version),
+      source,
+    };
+  }
+}
+
+function detectPackageManager(packageDir, packageJson) {
+  if (fs.existsSync(path.join(packageDir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(packageDir, 'yarn.lock'))) return 'yarn';
+  if (fs.existsSync(path.join(packageDir, 'package-lock.json'))) return 'npm';
+  if (typeof packageJson?.packageManager === 'string') {
+    return packageJson.packageManager.split('@')[0];
+  }
+  return null;
+}
+
+const TEST_TOOL_MARKERS = {
+  vitest: ['vitest'],
+  jest: ['jest', '@jest/core', 'ts-jest'],
+  mocha: ['mocha', '@types/mocha'],
+  cypress: ['cypress'],
+  playwright: ['playwright', '@playwright/test'],
+  'testing-library': ['@testing-library/react', '@testing-library/vue', '@testing-library/jest-dom'],
+};
+
+const COMPONENT_LIBRARY_MARKERS = {
+  'ant-design': ['antd', '@ant-design/icons', '@ant-design/pro-components'],
+  'element-plus': ['element-plus'],
+  'element-ui': ['element-ui'],
+  'ant-design-vue': ['ant-design-vue'],
+  'arco-design': ['@arco-design/web-react', '@arco-design/web-vue'],
+  'naive-ui': ['naive-ui'],
+  'vuetify': ['vuetify'],
+  'chakra-ui': ['@chakra-ui/react', '@chakra-ui/vue'],
+  'mui': ['@mui/material', '@mui/icons-material', '@mui/x-data-grid'],
+  'radix-ui': ['@radix-ui/react-dialog', '@radix-ui/react-dropdown-menu'],
+  'shadcn-ui': ['@shadcn/ui'],
+};
+
+function detectTestTools(allDeps) {
+  const found = [];
+  for (const [tool, markers] of Object.entries(TEST_TOOL_MARKERS)) {
+    if (markers.some((m) => allDeps[m])) {
+      found.push(tool);
+    }
+  }
+  return found;
+}
+
+function detectComponentLibraries(allDeps) {
+  const found = [];
+  for (const [lib, markers] of Object.entries(COMPONENT_LIBRARY_MARKERS)) {
+    if (markers.some((m) => allDeps[m])) {
+      found.push(lib);
+    }
+  }
+  return found;
+}
+
+function collectKeyPaths(packageDir) {
+  const candidates = [
+    'package.json',
+    'pnpm-workspace.yaml',
+    'vite.config.ts',
+    'vite.config.js',
+    'next.config.js',
+    'next.config.mjs',
+    'next.config.ts',
+    'src/app/layout.tsx',
+    'src/app/page.tsx',
+    'src/pages/_app.tsx',
+    'src/main.tsx',
+    'src/main.jsx',
+    'src/index.tsx',
+    'src/index.jsx',
+    'src/main.ts',
+    'src/main.js',
+    'src/App.tsx',
+    'config/webpack.config.js',
+    'webpack.config.js',
+    'nest-cli.json',
+    'src/app.module.ts',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'src/main/java',
+    'src/main/resources/application.yml',
+    'src/main/resources/application.properties',
+    'go.mod',
+    'main.go',
+    'pyproject.toml',
+    'requirements.txt',
+  ];
+  return candidates.filter((relativePath) => fs.existsSync(path.join(packageDir, relativePath)));
+}
+
+function extractJavaKeywords(text) {
+  const value = String(text || '').toLowerCase();
+  return {
+    springBoot: value.includes('spring-boot') || value.includes('org.springframework.boot'),
+    springCloud: value.includes('spring-cloud') || value.includes('org.springframework.cloud'),
+    springMvc: value.includes('spring-webmvc') || value.includes('springframework.web.servlet') || value.includes('spring-context'),
+    myBatis: value.includes('mybatis') || value.includes('mybatis-spring'),
+  };
+}
+
+function readRootPackageFacts(workspaceRoot) {
+  const packageJson = readJsonIfExists(path.join(workspaceRoot, 'package.json'));
+  const dependencies = {};
+  const devDependencies = {};
+  if (packageJson) {
+    addDependencies(dependencies, packageJson.dependencies, 'workspace-root');
+    addDependencies(devDependencies, packageJson.devDependencies, 'workspace-root');
+    addDependencies(dependencies, packageJson.peerDependencies, 'workspace-root');
+  }
+  return {
+    packageJson,
+    dependencies,
+    devDependencies,
+  };
+}
+
+class FactExtractor {
+  extract(input) {
+    const packageDir = path.resolve(input.rootDir);
+    const workspaceRoot = path.resolve(input.workspaceRoot || packageDir);
+    const packageJson = readJsonIfExists(path.join(packageDir, 'package.json'));
+    const rootFacts = packageDir === workspaceRoot
+      ? { packageJson, dependencies: {}, devDependencies: {} }
+      : readRootPackageFacts(workspaceRoot);
+    const dependencies = {};
+    const devDependencies = {};
+
+    addDependencies(dependencies, rootFacts.dependencies, 'workspace-root', false);
+    addDependencies(devDependencies, rootFacts.devDependencies, 'workspace-root', false);
+
+    if (packageJson) {
+      addDependencies(dependencies, packageJson.dependencies, 'local');
+      addDependencies(devDependencies, packageJson.devDependencies, 'local');
+      addDependencies(dependencies, packageJson.peerDependencies, 'local');
+    }
+
+    const pomXml = readTextIfExists(path.join(packageDir, 'pom.xml'));
+    const gradle = [
+      readTextIfExists(path.join(packageDir, 'build.gradle')),
+      readTextIfExists(path.join(packageDir, 'build.gradle.kts')),
+    ].filter(Boolean).join('\n');
+    const goMod = readTextIfExists(path.join(packageDir, 'go.mod'));
+    const requirementsTxt = readTextIfExists(path.join(packageDir, 'requirements.txt'));
+    const pyprojectToml = readTextIfExists(path.join(packageDir, 'pyproject.toml'));
+    const keyPaths = collectKeyPaths(packageDir);
+    const javaKeywords = extractJavaKeywords(`${pomXml}\n${gradle}`);
+
+    return {
+      packageId: input.relativePath === '.' ? 'root' : input.relativePath.replace(/[^a-zA-Z0-9_-]+/g, '_'),
+      name: packageJson?.name || null,
+      relativePath: input.relativePath || path.relative(workspaceRoot, packageDir) || '.',
+      rootDir: packageDir,
+      packageJson: packageJson || null,
+      packageManager: detectPackageManager(packageDir, packageJson),
+      scripts: packageJson?.scripts || {},
+      dependencies,
+      devDependencies,
+      testTools: detectTestTools({ ...dependencies, ...devDependencies }),
+      componentLibraries: detectComponentLibraries({ ...dependencies, ...devDependencies }),
+      manifestFiles: keyPaths.filter((item) => ['package.json', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'go.mod', 'pyproject.toml', 'requirements.txt'].includes(item)),
+      keyPaths,
+      java: {
+        pomXml,
+        gradle,
+        keywords: javaKeywords,
+      },
+      python: {
+        requirementsTxt,
+        pyprojectToml,
+      },
+      go: {
+        goMod,
+      },
+    };
+  }
+}
+
+module.exports = {
+  FactExtractor,
+};

package/src/scanner/types.js

@@ -0,0 +1,30 @@
+const SCANNER_SCHEMA_VERSION = 1;
+
+const PROJECT_TYPES = Object.freeze({
+  SINGLE: 'single-project',
+  NODE_WORKSPACE: 'node-workspace',
+  PNPM_WORKSPACE: 'pnpm-workspace',
+  PACKAGE_JSON_WORKSPACE: 'package-json-workspace',
+  LERNA_WORKSPACE: 'lerna-workspace',
+  TURBO_WORKSPACE: 'turbo-workspace',
+  NX_WORKSPACE: 'nx-workspace',
+  MAVEN_MULTI_MODULE: 'maven-multi-module',
+  GRADLE_MULTI_MODULE: 'gradle-multi-module',
+  MULTI_PROJECT_WORKSPACE: 'multi-project-workspace',
+  JAVA_PROJECT: 'java-project',
+  GO_PROJECT: 'go-project',
+  PYTHON_PROJECT: 'python-project',
+  UNKNOWN: 'unknown',
+});
+
+const DETECTION_CONFIDENCE = Object.freeze({
+  HIGH: 80,
+  MEDIUM: 60,
+  LOW: 30,
+});
+
+module.exports = {
+  SCANNER_SCHEMA_VERSION,
+  PROJECT_TYPES,
+  DETECTION_CONFIDENCE,
+};

package/src/security/asset-tamper-checker.js

@@ -0,0 +1,188 @@
+const fs = require('fs');
+const { GlobalCache } = require('../cache/global-cache');
+const { readProjectState } = require('../project/project-files');
+const { sha256File } = require('./checksum');
+
+const PRIVACY_FALSE_FIELDS = [
+  'uploadSourceCode',
+  'uploadAbsolutePath',
+  'uploadUserName',
+  'uploadRawPrompt',
+  'uploadRawResponse',
+  'uploadFileContent',
+];
+
+function issue(level, code, message, suggestion) {
+  return { level, code, message, suggestion };
+}
+
+function addIssue(result, item) {
+  result[`${item.level}s`].push(item);
+}
+
+function assetIdentity(asset) {
+  return `${asset.kind || 'asset'}:${asset.slug || ''}:${asset.version || ''}`;
+}
+
+function flattenRegistryAssets(registry) {
+  const assets = registry?.assets || {};
+  const result = [];
+  for (const [group, items] of Object.entries(assets)) {
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        result.push({
+          ...item,
+          kind: item.kind || (group === 'agentProfiles' ? 'agent-profile' : group.replace(/s$/, '')),
+        });
+      }
+    }
+  }
+  return result;
+}
+
+function containsContent(value) {
+  if (!value || typeof value !== 'object') return false;
+  if (Object.prototype.hasOwnProperty.call(value, 'content')) return true;
+  if (Array.isArray(value)) return value.some(containsContent);
+  return Object.values(value).some(containsContent);
+}
+
+class AssetTamperChecker {
+  constructor(options = {}) {
+    this.globalCache = options.globalCache || new GlobalCache(options);
+  }
+
+  check(rootDir, options = {}) {
+    const strictCache = Boolean(options.strictCache);
+    const result = {
+      passed: true,
+      errors: [],
+      warnings: [],
+      infos: [],
+    };
+    let state;
+    try {
+      state = readProjectState(rootDir);
+    } catch (error) {
+      addIssue(result, issue('error', 'JSON_INVALID', error.message, '请修复 JSON 格式后重新执行检查'));
+      result.passed = false;
+      return result;
+    }
+
+    const requiredFiles = [
+      ['project', '.ai-spec/project.json'],
+      ['policy', '.ai-spec/policy.json'],
+      ['lock', '.ai-spec/ai-spec.lock.json'],
+      ['registry', '.agents/registry.index.json'],
+      ['contextIndex', '.ai-spec/context-index.json'],
+    ];
+    for (const [key, label] of requiredFiles) {
+      if (!state[key]) {
+        addIssue(result, issue('error', `MISSING_${key.toUpperCase()}`, `缺少 ${label}`, '请先执行 ai-spec-auto init . --recommend --yes'));
+      }
+    }
+    if (result.errors.length > 0) {
+      result.passed = false;
+      return result;
+    }
+
+    this.checkPrivacy(state.policy, result);
+    this.checkLock(state.lock, result);
+    this.checkRegistry(state.lock, state.registry, result);
+    this.checkContextIndex(state.contextIndex, result);
+    this.checkAssetCache(state.lock, result, { strictCache });
+    this.checkOverlays(state.lock, result);
+
+    addIssue(result, issue('info', 'CHECK_COMPLETE', '资产完整性检查完成', '无需处理'));
+    result.passed = result.errors.length === 0;
+    return result;
+  }
+
+  checkPrivacy(policy, result) {
+    const privacy = policy.privacyPolicy || {};
+    for (const field of PRIVACY_FALSE_FIELDS) {
+      if (privacy[field] === true) {
+        addIssue(result, issue('error', 'PRIVACY_POLICY_VIOLATION', `隐私配置违规：privacyPolicy.${field} 不能为 true`, '请将该字段设置为 false'));
+      }
+    }
+  }
+
+  checkLock(lock, result) {
+    if (!lock.schemaVersion) {
+      addIssue(result, issue('error', 'LOCK_SCHEMA_MISSING', 'lock 缺少 schemaVersion', '请重新生成 ai-spec.lock.json'));
+    }
+    if (lock.manifest && !lock.manifest.checksum) {
+      addIssue(result, issue('error', 'MANIFEST_CHECKSUM_MISSING', 'manifest checksum 字段缺失', '请重新执行 sync 或 init'));
+    }
+    if (!lock.manifest) {
+      addIssue(result, issue('warning', 'MANIFEST_NOT_INSTALLED', 'lock 未包含 Manifest', '如需安装规范，请使用 --manifest 手动指定'));
+    }
+    for (const asset of lock.assets || []) {
+      if (!asset.checksum) {
+        addIssue(result, issue('error', 'ASSET_CHECKSUM_MISSING', `资产 ${asset.slug || ''} 缺少 checksum`, '请修正 lock 文件'));
+      }
+    }
+    for (const profile of lock.agentProfiles || []) {
+      if (!profile.checksum) {
+        addIssue(result, issue('error', 'AGENT_PROFILE_CHECKSUM_MISSING', `Agent Profile ${profile.slug || ''} 缺少 checksum`, '请修正 lock 文件'));
+      }
+    }
+  }
+
+  checkRegistry(lock, registry, result) {
+    if (containsContent(registry)) {
+      addIssue(result, issue('error', 'REGISTRY_CONTENT_FORBIDDEN', 'registry.index.json 不允许包含完整 content', '请只保留 cacheKey/cachePath/checksum 索引'));
+    }
+    const registryAssets = flattenRegistryAssets(registry);
+    const registryByIdentity = new Map(registryAssets.map((asset) => [assetIdentity(asset), asset]));
+    for (const asset of lock.assets || []) {
+      const registryAsset = registryByIdentity.get(assetIdentity(asset));
+      if (!registryAsset) {
+        addIssue(result, issue('error', 'REGISTRY_ASSET_MISSING', `registry 缺少资产索引：${asset.slug || asset.checksum}`, '请执行 ai-spec-auto sync . 重新生成索引'));
+        continue;
+      }
+      if (registryAsset.checksum !== asset.checksum) {
+        addIssue(result, issue('error', 'REGISTRY_LOCK_MISMATCH', `registry 与 lock checksum 不一致：${asset.slug || asset.checksum}`, '请执行 ai-spec-auto sync . 重新生成索引'));
+      }
+    }
+  }
+
+  checkContextIndex(contextIndex, result) {
+    if (contextIndex.contextStrategy !== 'progressive') {
+      addIssue(result, issue('error', 'CONTEXT_STRATEGY_INVALID', 'contextStrategy 必须是 progressive', '请重新生成 context-index.json'));
+    }
+    const stages = new Set((contextIndex.stageLoadRules || []).map((item) => item.stage));
+    for (const stage of ['planning', 'implementation', 'verification', 'diagnosing']) {
+      if (!stages.has(stage)) {
+        addIssue(result, issue('error', 'CONTEXT_STAGE_MISSING', `context-index 缺少 ${stage} 阶段`, '请重新生成 context-index.json'));
+      }
+    }
+  }
+
+  checkAssetCache(lock, result, options = {}) {
+    for (const asset of lock.assets || []) {
+      if (!asset.checksum) continue;
+      const contentPath = this.globalCache.getAssetContentPath(asset.checksum);
+      if (!fs.existsSync(contentPath)) {
+        addIssue(result, issue(options.strictCache ? 'error' : 'warning', 'ASSET_CACHE_MISSING', `缓存缺失：${asset.slug || asset.checksum}`, '请先执行 ai-spec-auto sync .'));
+        continue;
+      }
+      const actual = sha256File(contentPath);
+      if (actual !== asset.checksum) {
+        addIssue(result, issue('error', 'ASSET_TAMPERED', `标准资产 checksum 不一致：${asset.slug || asset.checksum}`, '请执行 ai-spec-auto sync . 恢复缓存'));
+      }
+    }
+  }
+
+  checkOverlays(lock, result) {
+    if (Array.isArray(lock.overlays) && lock.overlays.length > 0) {
+      addIssue(result, issue('warning', 'OVERLAY_CHECK_NOT_IMPLEMENTED', 'overlay checksum 校验暂未实现', '后续实现 overlay 后补充校验'));
+    }
+  }
+}
+
+module.exports = {
+  AssetTamperChecker,
+  PRIVACY_FALSE_FIELDS,
+  flattenRegistryAssets,
+};

package/src/security/checksum.js

@@ -0,0 +1,40 @@
+const crypto = require('crypto');
+const fs = require('fs');
+
+function sha256Text(text) {
+  if (text === undefined || text === null) {
+    throw new Error('内容不能为空，无法计算 checksum');
+  }
+  return `sha256:${crypto.createHash('sha256').update(String(text)).digest('hex')}`;
+}
+
+function sha256File(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    throw new Error(`文件不存在，无法计算 checksum：${filePath || '未提供路径'}`);
+  }
+  return sha256Text(fs.readFileSync(filePath));
+}
+
+function stableStringify(value) {
+  if (value === undefined || value === null) {
+    throw new Error('JSON 内容不能为空，无法计算 checksum');
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  }
+  if (typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function safeJsonHash(object) {
+  return sha256Text(stableStringify(object));
+}
+
+module.exports = {
+  safeJsonHash,
+  sha256File,
+  sha256Text,
+  stableStringify,
+};