@gong-ym/ai-spec-auto 0.2.3

package/src/init/init-plan.js

@@ -0,0 +1,294 @@
+const fs = require('fs');
+const path = require('path');
+const { PROJECT_TYPES } = require('../scanner/types');
+const { ManifestInstaller } = require('./manifest-installer');
+const { FactExtractor } = require('../scanner/facts/fact-extractor');
+const { DetectorRegistry } = require('../scanner/detectors/detector-registry');
+const { INIT_FILE_ACTIONS, MANIFEST_CONFIDENCE, PROJECT_KINDS } = require('./types');
+
+const WORKSPACE_TYPES = new Set([
+  PROJECT_TYPES.NODE_WORKSPACE,
+  PROJECT_TYPES.PNPM_WORKSPACE,
+  PROJECT_TYPES.PACKAGE_JSON_WORKSPACE,
+  PROJECT_TYPES.LERNA_WORKSPACE,
+  PROJECT_TYPES.TURBO_WORKSPACE,
+  PROJECT_TYPES.NX_WORKSPACE,
+  PROJECT_TYPES.MAVEN_MULTI_MODULE,
+  PROJECT_TYPES.GRADLE_MULTI_MODULE,
+  PROJECT_TYPES.MULTI_PROJECT_WORKSPACE,
+]);
+
+function detectDomain(primary, tags) {
+  const values = new Set([...(primary?.tags || []), ...(tags || [])]);
+  if (values.has('frontend')) return 'frontend';
+  if (values.has('backend')) return 'backend';
+  return 'unknown';
+}
+
+function buildTechProfile(pkg) {
+  const primary = pkg.primary || null;
+  return {
+    domain: detectDomain(primary, pkg.tags),
+    language: primary?.language || [],
+    frameworks: primary?.framework ? [primary.framework] : [],
+    buildTool: primary?.buildTool || '',
+    confidence: primary?.confidence || 0,
+    reasons: primary?.reasons || pkg.reasons || [],
+  };
+}
+
+function readPackageJson(rootDir, pkg) {
+  const packageJsonPath = path.join(rootDir, pkg.path || '.', 'package.json');
+  if (!fs.existsSync(packageJsonPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function hasFrontendBusinessEntry(rootDir, pkg) {
+  const packageDir = path.join(rootDir, pkg.path || '.');
+  return [
+    'src/app',
+    'src/pages',
+    'vite.config.js',
+    'vite.config.ts',
+    'next.config.js',
+    'next.config.mjs',
+    'next.config.ts',
+    'src/index.tsx',
+    'src/index.jsx',
+    'config/webpack.config.js',
+    'webpack.config.js',
+  ].some((relativePath) => fs.existsSync(path.join(packageDir, relativePath)));
+}
+
+function hasCliName(name) {
+  return /\b(cli|spec|tool|auto)\b/i.test(String(name || '').replace(/[@/_-]+/g, ' '));
+}
+
+function detectProjectKind(rootDir, pkg) {
+  const packageJson = readPackageJson(rootDir, pkg);
+  const packageDir = path.join(rootDir, pkg.path || '.');
+  if (packageJson?.bin || fs.existsSync(path.join(packageDir, 'bin/cli.js'))) {
+    return PROJECT_KINDS.CLI_TOOL;
+  }
+
+  const primary = pkg.primary || null;
+  if (hasCliName(packageJson?.name || pkg.name) && (!primary || !hasFrontendBusinessEntry(rootDir, pkg))) {
+    return PROJECT_KINDS.CLI_TOOL;
+  }
+
+  if (!primary) {
+    if (packageJson?.main || packageJson?.module || packageJson?.exports || packageJson?.types) {
+      return PROJECT_KINDS.LIBRARY;
+    }
+    return PROJECT_KINDS.UNKNOWN;
+  }
+
+  if ((primary.tags || []).includes('frontend') && !hasFrontendBusinessEntry(rootDir, pkg)) {
+    return PROJECT_KINDS.LIBRARY;
+  }
+
+  return PROJECT_KINDS.APPLICATION;
+}
+
+function buildRecommendationWarnings(pkg, projectKind, recommendedManifest) {
+  const warnings = [];
+  if (!pkg.primary) {
+    warnings.push('未识别到明确技术栈，不自动推荐 Manifest');
+  }
+  if (projectKind === PROJECT_KINDS.CLI_TOOL) {
+    warnings.push('当前项目被识别为 cli-tool，不自动推荐前端业务 Manifest');
+  }
+  if (pkg.primary && (pkg.primary.confidence || 0) < MANIFEST_CONFIDENCE.REQUIRE_CONFIRM) {
+    warnings.push('技术栈识别置信度低于 60，不自动推荐 Manifest');
+  }
+  for (const warning of recommendedManifest?.warnings || []) {
+    warnings.push(warning);
+  }
+  return warnings;
+}
+
+function findHubRecommendation(pkg, recommendations = []) {
+  return recommendations.find((item) => item.packageId === pkg.packageId || item.packageId === pkg.path) || null;
+}
+
+function fileAction(rootDir, relativePath, enabled = true) {
+  if (!enabled) return INIT_FILE_ACTIONS.SKIP;
+  return fs.existsSync(path.join(rootDir, relativePath)) ? INIT_FILE_ACTIONS.UPDATE : INIT_FILE_ACTIONS.CREATE;
+}
+
+function buildFilesToWrite(rootDir, scanResult, workspaceRoot = false) {
+  const isWorkspace = !workspaceRoot && (WORKSPACE_TYPES.has(scanResult.workspace.type) || scanResult.packages.length > 1);
+  return [
+    {
+      path: '.ai-spec/project.json',
+      action: fileAction(rootDir, '.ai-spec/project.json'),
+      description: '写入项目画像与 Manifest 推荐结果',
+      requireConfirm: true,
+    },
+    {
+      path: '.ai-spec/policy.json',
+      action: fileAction(rootDir, '.ai-spec/policy.json'),
+      description: '写入本地执行、分支与隐私策略',
+      requireConfirm: true,
+    },
+    {
+      path: '.ai-spec/workspace.json',
+      action: fileAction(rootDir, '.ai-spec/workspace.json', isWorkspace),
+      description: '写入多包工作区拓扑',
+      requireConfirm: true,
+    },
+    {
+      path: '.ai-spec/ai-spec.lock.json',
+      action: fileAction(rootDir, '.ai-spec/ai-spec.lock.json'),
+      description: '写入 Manifest 与资产锁定索引',
+      requireConfirm: true,
+    },
+    {
+      path: '.agents/registry.index.json',
+      action: fileAction(rootDir, '.agents/registry.index.json'),
+      description: '写入本地 Registry 索引',
+      requireConfirm: true,
+    },
+    {
+      path: '.ai-spec/context-index.json',
+      action: fileAction(rootDir, '.ai-spec/context-index.json'),
+      description: '写入渐进式上下文索引',
+      requireConfirm: true,
+    },
+    {
+      path: '.codex/instructions.md',
+      action: fileAction(rootDir, '.codex/instructions.md'),
+      description: '注入 Codex 指针文件',
+      requireConfirm: true,
+    },
+    {
+      path: '.cursor/rules/ai-spec-auto.mdc',
+      action: fileAction(rootDir, '.cursor/rules/ai-spec-auto.mdc'),
+      description: '注入 Cursor 指针文件',
+      requireConfirm: true,
+    },
+    {
+      path: 'CLAUDE.md',
+      action: fileAction(rootDir, 'CLAUDE.md'),
+      description: '注入 Claude Code 指针文件',
+      requireConfirm: true,
+    },
+    {
+      path: 'memory.md',
+      action: fileAction(rootDir, 'memory.md'),
+      description: '注入本地记忆入口指针',
+      requireConfirm: true,
+    },
+  ];
+}
+
+class InitPlanBuilder {
+  constructor(options = {}) {
+    this.manifestInstaller = options.manifestInstaller || new ManifestInstaller();
+  }
+
+  build(scanResult, options = {}) {
+    const rootDir = scanResult.workspace.rootDir;
+    let scanPackages = scanResult.packages;
+    if (options.workspaceRoot) {
+      const rootPkg = scanPackages.find((pkg) => pkg.path === '.');
+      if (rootPkg) {
+        scanPackages = [rootPkg];
+      } else if (fs.existsSync(path.join(rootDir, 'package.json'))) {
+        const factExtractor = options.factExtractor || new FactExtractor();
+        const detectorRegistry = options.detectorRegistry || new DetectorRegistry();
+        const facts = factExtractor.extract({
+          rootDir,
+          relativePath: '.',
+          workspaceRoot: rootDir,
+        });
+        const detection = detectorRegistry.detect(facts);
+        const primary = detection.primary || null;
+        scanPackages = [{
+          packageId: '.',
+          name: facts.name || path.basename(rootDir),
+          path: '.',
+          primary,
+          tags: detection.tags || [],
+          reasons: primary?.reasons || ['--workspace-root 模式，仅初始化根目录'],
+          candidates: detection.candidates || [],
+        }];
+      } else {
+        scanPackages = [];
+      }
+    }
+    const packages = scanPackages.map((pkg) => {
+      const projectKind = detectProjectKind(rootDir, pkg);
+      const recommendationInput = {
+        ...pkg,
+        projectKind,
+      };
+      const hubRecommendation = findHubRecommendation(pkg, options.hubRecommendations);
+      const recommendedManifest = hubRecommendation?.manifest
+        ? {
+          slug: hubRecommendation.manifest.slug,
+          version: hubRecommendation.manifest.version || '1.0.0',
+          score: hubRecommendation.score || 0,
+          reasons: hubRecommendation.reasons || ['Hub 推荐 Manifest'],
+          warnings: hubRecommendation.requiresConfirmation ? ['Hub 推荐要求人工确认'] : [],
+          requiresConfirmation: hubRecommendation.requiresConfirmation === true,
+        }
+        : this.manifestInstaller.recommendForPackage(recommendationInput, {
+          manualManifestSlug: options.manualManifestSlug,
+        });
+      const warnings = buildRecommendationWarnings(pkg, projectKind, recommendedManifest);
+      return {
+        packageId: pkg.packageId,
+        name: pkg.name,
+        path: pkg.path,
+        projectKind,
+        techProfile: buildTechProfile(pkg),
+        primary: pkg.primary || null,
+        recommendedManifest: recommendedManifest ? {
+          slug: recommendedManifest.slug,
+          version: recommendedManifest.version,
+          score: recommendedManifest.score,
+          reasons: recommendedManifest.reasons,
+          requiresConfirmation: recommendedManifest.requiresConfirmation,
+          checksum: recommendedManifest.checksum,
+        } : null,
+        recommendationSource: recommendedManifest ? (options.recommendationSource || 'local') : 'none',
+        candidates: pkg.candidates || [],
+        warnings,
+      };
+    });
+
+    const warnings = [];
+    if (packages.length === 0) {
+      warnings.push('未发现可初始化的项目包');
+    }
+    if (packages.some((pkg) => pkg.techProfile.confidence < 60)) {
+      warnings.push('存在低置信度技术栈识别结果，建议人工确认 Manifest');
+    }
+    for (const pkg of packages) {
+      for (const warning of pkg.warnings || []) {
+        if (!warnings.includes(warning)) warnings.push(warning);
+      }
+    }
+
+    return {
+      workspace: scanResult.workspace,
+      packages,
+      filesToWrite: buildFilesToWrite(rootDir, scanResult, options.workspaceRoot),
+      warnings,
+      requiresConfirmation: true,
+      recommendationSource: options.recommendationSource || 'local',
+      hub: options.hubConfig || null,
+    };
+  }
+}
+
+module.exports = {
+  InitPlanBuilder,
+  WORKSPACE_TYPES,
+  buildTechProfile,
+};

package/src/init/init-service.js

@@ -0,0 +1,65 @@
+const { TechScannerEngine } = require('../scanner/engine');
+const { resolveHubConfig } = require('../hub/hub-config');
+const { HubClient } = require('../hub/hub-client');
+const { toHubWorkspace, toProjectFacts } = require('../hub/project-facts');
+const { InitPlanBuilder } = require('./init-plan');
+
+class InitService {
+  constructor(options = {}) {
+    this.scanner = options.scanner || new TechScannerEngine();
+    this.planBuilder = options.planBuilder || new InitPlanBuilder();
+    this.hubClient = options.hubClient || new HubClient();
+  }
+
+  async createPlan(rootDir, options = {}) {
+    const scanResult = await this.scanner.scan(rootDir, options.scanOptions || {});
+    const hubConfig = resolveHubConfig(rootDir, options);
+    if (options.manualManifestSlug) {
+      return this.planBuilder.build(scanResult, {
+        manualManifestSlug: options.manualManifestSlug,
+        recommendationSource: 'manual',
+        hubConfig,
+        workspaceRoot: options.workspaceRoot,
+      });
+    }
+
+    if (!hubConfig.url || hubConfig.enabled === false) {
+      const plan = this.planBuilder.build(scanResult, {
+        recommendationSource: 'local',
+        hubConfig,
+        workspaceRoot: options.workspaceRoot,
+      });
+      plan.warnings.push('未配置 Hub URL，已使用本地模式');
+      return plan;
+    }
+
+    try {
+      const hubRecommendations = await this.hubClient.recommendManifests({
+        hubUrl: hubConfig.url,
+        workspace: toHubWorkspace(scanResult),
+        projectFacts: toProjectFacts(scanResult),
+      });
+      return this.planBuilder.build(scanResult, {
+        hubRecommendations: hubRecommendations.recommendations || [],
+        recommendationSource: 'hub',
+        hubConfig,
+        workspaceRoot: options.workspaceRoot,
+      });
+    } catch (error) {
+      if (hubConfig.fallbackToLocal) {
+        const plan = this.planBuilder.build(scanResult, {
+          recommendationSource: 'local',
+          hubConfig,
+          workspaceRoot: options.workspaceRoot,
+        });
+        plan.warnings.push(`Hub 推荐失败，已降级本地推荐：${error.message}`);
+        return plan;
+      }
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  InitService,
+};

package/src/init/manifest-installer.js

@@ -0,0 +1,302 @@
+const fs = require('fs');
+const path = require('path');
+const { createChecksum } = require('../project/json-utils');
+const { MANIFEST_CONFIDENCE, PROJECT_KINDS } = require('./types');
+
+const FRAMEWORK_MANIFESTS = Object.freeze({
+  nextjs: 'frontend-react-nextjs-standard',
+  'react-vite': 'frontend-react-vite-standard',
+  'react-webpack': 'frontend-react-standard',
+  'vue-vite': 'frontend-vue-vite-standard',
+  'spring-boot': 'backend-java-springboot-standard',
+  'spring-mvc': 'backend-java-springmvc-legacy-standard',
+  'spring-cloud': 'backend-java-springcloud-standard',
+  nestjs: 'backend-node-nestjs-standard',
+  fastapi: 'backend-python-fastapi-standard',
+  go: 'backend-go-standard',
+});
+
+/** Manifest slug → profile 目录名映射，用于选择对应的 profile rules/skills */
+const MANIFEST_TO_PROFILE = Object.freeze({
+  'frontend-vue-vite-standard': 'vue',
+  'frontend-react-vite-standard': 'react',
+  'frontend-react-standard': 'react',
+  'frontend-react-nextjs-standard': 'react',
+  'backend-java-springboot-standard': 'springboot',
+  'backend-java-springmvc-legacy-standard': 'springboot',
+  'backend-java-springcloud-standard': 'springboot',
+  'backend-node-nestjs-standard': 'nestjs',
+});
+
+/** 需要从 br-ai-spec 复制到目标项目的 .agents 子目录 */
+const AGENT_ASSET_DIRS = ['rules', 'skills', 'roles', 'commands', 'flows', 'orchestration', 'templates'];
+
+class HubClient {
+  async resolveManifest(_slug, _version) {
+    return null;
+  }
+}
+
+/** 递归复制目录 */
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else if (entry.isSymbolicLink()) {
+      try {
+        const realPath = fs.realpathSync(srcPath);
+        if (fs.statSync(realPath).isDirectory()) {
+          copyDirSync(realPath, destPath);
+        } else {
+          fs.copyFileSync(realPath, destPath);
+        }
+      } catch (_) {
+        // symlink 无法解析则跳过
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/** 合并复制：先复制 baseDir 下所有文件到 destDir，再用 overlayDir 覆盖 */
+function mergeCopyDirs(baseDir, overlayDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  // 先复制 base
+  if (fs.existsSync(baseDir)) {
+    for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+      const srcPath = path.join(baseDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (entry.isDirectory()) {
+        copyDirSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+  // 再覆盖 overlay
+  if (fs.existsSync(overlayDir)) {
+    for (const entry of fs.readdirSync(overlayDir, { withFileTypes: true })) {
+      const srcPath = path.join(overlayDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (entry.isDirectory()) {
+        copyDirSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+/**
+ * 安装扁平化后的 rules：
+ *   只安装 common/ 下的通用规则。profile 专属规则（01/03/04/05/06/07/09/11/13）
+ *   应由 project-init 技能基于实际项目扫描结果生成，不在 init 阶段复制模板。
+ */
+function installRulesFlat(sourceAgentsDir, targetAgentsDir, _profile) {
+  const destDir = path.join(targetAgentsDir, 'rules');
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+
+  const commonDir = path.join(sourceAgentsDir, 'rules', 'common');
+  if (!fs.existsSync(commonDir)) return false;
+  copyDirSync(commonDir, destDir);
+
+  // 保留 rules/ 根目录下的 README.md
+  const readmePath = path.join(sourceAgentsDir, 'rules', 'README.md');
+  if (fs.existsSync(readmePath)) {
+    fs.copyFileSync(readmePath, path.join(destDir, 'README.md'));
+  }
+  return true;
+}
+
+/**
+ * 安装扁平化后的 skills：
+ *   合并 common/ + domains/ + profiles/<profile>/ 下的所有目录
+ */
+function installSkillsFlat(sourceAgentsDir, targetAgentsDir, profile) {
+  const destDir = path.join(targetAgentsDir, 'skills');
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const sourceSkillsDir = path.join(sourceAgentsDir, 'skills');
+  const dirsToMerge = [];
+  for (const sub of ['common', 'domains']) {
+    const subDir = path.join(sourceSkillsDir, sub);
+    if (fs.existsSync(subDir)) dirsToMerge.push(subDir);
+  }
+  if (profile) {
+    const profileDir = path.join(sourceSkillsDir, 'profiles', profile);
+    if (fs.existsSync(profileDir)) dirsToMerge.push(profileDir);
+  }
+
+  for (const srcDir of dirsToMerge) {
+    for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const srcPath = path.join(srcDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (fs.existsSync(destPath)) {
+        fs.rmSync(destPath, { recursive: true, force: true });
+      }
+      copyDirSync(srcPath, destPath);
+    }
+  }
+
+  // 保留 skills/ 根目录下的 README.md
+  const readmePath = path.join(sourceSkillsDir, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    fs.copyFileSync(readmePath, path.join(destDir, 'README.md'));
+  }
+  return true;
+}
+
+class ManifestInstaller {
+  constructor(options = {}) {
+    this.hubClient = options.hubClient || new HubClient();
+    this.pkgRoot = options.pkgRoot || path.join(__dirname, '..', '..');
+  }
+
+  recommendForPackage(pkg, options = {}) {
+    if (options.manualManifestSlug) {
+      return {
+        slug: options.manualManifestSlug,
+        version: '1.0.0',
+        score: 100,
+        reasons: ['用户通过 --manifest 手动指定 Manifest'],
+        warnings: ['这是用户手动指定的 Manifest，未接入真实 Hub API 校验'],
+        requiresConfirmation: false,
+        checksum: createChecksum(`${options.manualManifestSlug}@1.0.0`),
+      };
+    }
+
+    const primary = pkg.primary || null;
+    if (!primary) {
+      return null;
+    }
+
+    if (pkg.projectKind === PROJECT_KINDS.CLI_TOOL) {
+      return null;
+    }
+    if (pkg.projectKind === PROJECT_KINDS.LIBRARY && (primary.tags || []).includes('frontend')) {
+      return null;
+    }
+
+    const framework = primary?.framework || null;
+    const slug = FRAMEWORK_MANIFESTS[framework];
+    if (!slug) {
+      return null;
+    }
+
+    const score = primary?.confidence || 0;
+    if (score < MANIFEST_CONFIDENCE.REQUIRE_CONFIRM) {
+      return null;
+    }
+
+    const reasons = [];
+
+    reasons.push(`根据 scanner primary ${framework} 推荐 ${slug}`);
+    for (const reason of primary?.reasons || []) {
+      reasons.push(reason);
+    }
+
+    return {
+      slug,
+      version: '1.0.0',
+      score,
+      reasons,
+      warnings: score < MANIFEST_CONFIDENCE.AUTO_SELECT ? ['技术栈识别置信度低于 80，需要人工确认'] : [],
+      requiresConfirmation: score < MANIFEST_CONFIDENCE.AUTO_SELECT,
+      checksum: createChecksum(`${slug}@1.0.0`),
+    };
+  }
+
+  /**
+   * 将 br-ai-spec 的 .agents 资产复制到目标项目，并扁平化 rules 和 skills
+   */
+  install(plan) {
+    const rootDir = plan.workspace?.rootDir;
+    if (!rootDir) {
+      return {
+        source: 'local',
+        manifest: plan.packages[0]?.recommendedManifest || null,
+        assets: [],
+        overlays: [],
+        sharedContracts: [],
+      };
+    }
+
+    const sourceAgentsDir = path.join(this.pkgRoot, '.agents');
+    const targetAgentsDir = path.join(rootDir, '.agents');
+
+    if (!fs.existsSync(sourceAgentsDir)) {
+      return {
+        source: 'local',
+        manifest: plan.packages[0]?.recommendedManifest || null,
+        assets: [],
+        overlays: [],
+        sharedContracts: [],
+        warnings: ['本地 .agents 源目录不存在，未安装资产文件'],
+      };
+    }
+
+    // 根据 recommendedManifest 确定 profile
+    const manifestSlug = plan.packages[0]?.recommendedManifest?.slug || null;
+    const profile = MANIFEST_TO_PROFILE[manifestSlug] || null;
+
+    const installedAssets = [];
+
+    // rules: 扁平化安装
+    if (installRulesFlat(sourceAgentsDir, targetAgentsDir, profile)) {
+      installedAssets.push('.agents/rules/');
+    }
+
+    // skills: 扁平化安装
+    if (installSkillsFlat(sourceAgentsDir, targetAgentsDir, profile)) {
+      installedAssets.push('.agents/skills/');
+    }
+
+    // 其余目录直接复制
+    for (const dir of AGENT_ASSET_DIRS) {
+      if (dir === 'rules' || dir === 'skills') continue;
+
+      const srcDir = path.join(sourceAgentsDir, dir);
+      const destDir = path.join(targetAgentsDir, dir);
+
+      if (!fs.existsSync(srcDir)) continue;
+
+      try {
+        if (fs.existsSync(destDir)) {
+          fs.rmSync(destDir, { recursive: true, force: true });
+        }
+        copyDirSync(srcDir, destDir);
+        installedAssets.push(`.agents/${dir}/`);
+      } catch (error) {
+        installedAssets.push(`.agents/${dir}/ (失败: ${error.message})`);
+      }
+    }
+
+    return {
+      source: 'local',
+      manifest: plan.packages[0]?.recommendedManifest || null,
+      assets: installedAssets,
+      overlays: [],
+      sharedContracts: [],
+    };
+  }
+}
+
+module.exports = {
+  AGENT_ASSET_DIRS,
+  FRAMEWORK_MANIFESTS,
+  MANIFEST_TO_PROFILE,
+  HubClient,
+  ManifestInstaller,
+  copyDirSync,
+  mergeCopyDirs,
+};

package/src/init/types.js

@@ -0,0 +1,26 @@
+const INIT_SCHEMA_VERSION = '1.0.0';
+
+const INIT_FILE_ACTIONS = Object.freeze({
+  CREATE: 'create',
+  UPDATE: 'update',
+  SKIP: 'skip',
+});
+
+const PROJECT_KINDS = Object.freeze({
+  APPLICATION: 'application',
+  CLI_TOOL: 'cli-tool',
+  LIBRARY: 'library',
+  UNKNOWN: 'unknown',
+});
+
+const MANIFEST_CONFIDENCE = Object.freeze({
+  AUTO_SELECT: 80,
+  REQUIRE_CONFIRM: 60,
+});
+
+module.exports = {
+  INIT_SCHEMA_VERSION,
+  INIT_FILE_ACTIONS,
+  MANIFEST_CONFIDENCE,
+  PROJECT_KINDS,
+};