@zhuan-ai/zhuanspec 2.2.2 → 2.2.3

package/dist/core/init.d.ts

@@ -50,9 +50,23 @@ export declare class InitCommand {
     private fetchRemoteArchitectureContent;
     private cloneRemoteArchitectureRepoToTemp;
     private syncBusinessSpecTemplate;
+    private syncBusinessClaudeAssets;
+    private resolveBusinessDirectionRoot;
     private findFirstDirectoryByName;
     private findFirstTemplateSourceRoot;
     private copyDirectoryContentsIfExists;
+    private resolveClaudeAssetSource;
+    private copyClaudeFileIfNeeded;
+    private copyClaudeDirectoryIfNeeded;
+    private copyClaudeDirectoryWithFallback;
+    private copyClaudeDirectoryFromSingleSource;
+    private directoryHasAtLeastOneFile;
+    private copyClaudeDirectoryByFileSystem;
+    private findGitRootForPath;
+    private safeRealpath;
+    private copyGitTrackedDirectoryFiles;
+    private mergeDirectoryWithoutOverwrite;
+    private describeClaudeAssetResult;
     private writeTemplateFiles;
     private configureAITools;
     private configureRootAgentsStub;

package/dist/core/init.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import os from 'os';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, } from 'fs';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, realpathSync, writeFileSync, readdirSync, readFileSync, rmSync, } from 'fs';
 import { createPrompt, isBackspaceKey, isDownKey, isEnterKey, isSpaceKey, isUpKey, useKeypress, usePagination, useState, } from '@inquirer/core';
 import chalk from 'chalk';
 import ora from 'ora';
@@ -339,6 +339,14 @@ export class InitCommand {
                     text: PALETTE.midGray(`未找到 ${this.businessDirection} 业务规范模板目录，保留默认模板`),
                 });
             }
+            const claudeAssetSpinner = this.startSpinner(`正在同步 ${this.businessDirection} 业务 Claude 规范资产...`);
+            const claudeAssetResult = this.syncBusinessClaudeAssets(projectPath);
+            const claudeMdText = this.describeClaudeAssetResult('CLAUDE.md', claudeAssetResult.claudeMd);
+            const dotClaudeText = this.describeClaudeAssetResult('.claude', claudeAssetResult.dotClaude);
+            claudeAssetSpinner.stopAndPersist({
+                symbol: PALETTE.white('▌'),
+                text: PALETTE.white(`Claude 规范资产同步完成：${claudeMdText}；${dotClaudeText}`),
+            });
         }
         // Success message
         this.displaySuccessMessage(selectedTools, created, refreshed, skippedExisting, skipped, extendMode, rootStubStatus);
@@ -760,7 +768,7 @@ export class InitCommand {
         }
         try {
             const specsRoot = path.join(tempDir, 'specs');
-            const businessRoot = this.findFirstDirectoryByName(specsRoot, this.businessDirection);
+            const businessRoot = this.resolveBusinessDirectionRoot(specsRoot);
             if (!businessRoot) {
                 return { syncedSpecs: false, syncedChanges: false };
             }
@@ -779,6 +787,53 @@ export class InitCommand {
             rmSync(tempDir, { recursive: true, force: true });
         }
     }
+    syncBusinessClaudeAssets(projectPath) {
+        const fallbackResult = {
+            claudeMd: { source: 'none', status: 'missing' },
+            dotClaude: { source: 'none', status: 'missing' },
+        };
+        if (!this.businessDirection) {
+            return fallbackResult;
+        }
+        const tempDir = this.cloneRemoteArchitectureRepoToTemp();
+        if (!tempDir) {
+            return fallbackResult;
+        }
+        try {
+            const specsRoot = path.join(tempDir, 'specs');
+            const businessRoot = this.resolveBusinessDirectionRoot(specsRoot);
+            const commonClaudeRoot = path.join(specsRoot, 'common', 'claude');
+            const businessClaudeMd = businessRoot
+                ? path.join(businessRoot, 'CLAUDE.md')
+                : null;
+            const commonClaudeMd = path.join(commonClaudeRoot, 'CLAUDE.md');
+            const resolvedClaudeMdSource = this.resolveClaudeAssetSource(businessClaudeMd, commonClaudeMd);
+            const businessDotClaude = businessRoot
+                ? path.join(businessRoot, '.claude')
+                : null;
+            const commonDotClaude = path.join(commonClaudeRoot, '.claude');
+            return {
+                claudeMd: this.copyClaudeFileIfNeeded(resolvedClaudeMdSource, path.join(projectPath, 'CLAUDE.md')),
+                dotClaude: this.copyClaudeDirectoryWithFallback(businessDotClaude, commonDotClaude, path.join(projectPath, '.claude')),
+            };
+        }
+        catch {
+            return fallbackResult;
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+    resolveBusinessDirectionRoot(specsRoot) {
+        if (!this.businessDirection) {
+            return null;
+        }
+        const directRoot = path.join(specsRoot, this.businessDirection);
+        if (existsSync(directRoot)) {
+            return directRoot;
+        }
+        return this.findFirstDirectoryByName(specsRoot, this.businessDirection);
+    }
     findFirstDirectoryByName(searchRoot, targetName) {
         if (!existsSync(searchRoot)) {
             return null;
@@ -850,6 +905,197 @@ export class InitCommand {
         }
         return true;
     }
+    resolveClaudeAssetSource(businessPath, commonPath) {
+        if (businessPath && existsSync(businessPath)) {
+            return { source: 'business', path: businessPath };
+        }
+        if (existsSync(commonPath)) {
+            return { source: 'common', path: commonPath };
+        }
+        return null;
+    }
+    copyClaudeFileIfNeeded(sourceAsset, targetPath) {
+        if (!sourceAsset) {
+            return { source: 'none', status: 'missing' };
+        }
+        if (existsSync(targetPath)) {
+            return { source: sourceAsset.source, status: 'kept-existing' };
+        }
+        cpSync(sourceAsset.path, targetPath, { force: false });
+        return { source: sourceAsset.source, status: 'copied' };
+    }
+    copyClaudeDirectoryIfNeeded(sourceAsset, targetPath) {
+        if (!sourceAsset) {
+            return { source: 'none', status: 'missing' };
+        }
+        if (!existsSync(sourceAsset.path)) {
+            return { source: sourceAsset.source, status: 'missing' };
+        }
+        const repoRoot = this.findGitRootForPath(sourceAsset.path);
+        if (!repoRoot) {
+            return this.copyClaudeDirectoryByFileSystem(sourceAsset, targetPath);
+        }
+        const canonicalRepoRoot = this.safeRealpath(repoRoot);
+        const canonicalSourcePath = this.safeRealpath(sourceAsset.path);
+        const relativeSourceDir = path
+            .relative(canonicalRepoRoot, canonicalSourcePath)
+            .split(path.sep)
+            .join('/');
+        if (relativeSourceDir.startsWith('..') ||
+            path.isAbsolute(relativeSourceDir)) {
+            return this.copyClaudeDirectoryByFileSystem(sourceAsset, targetPath);
+        }
+        const targetAlreadyExisted = existsSync(targetPath);
+        const copiedAny = this.copyGitTrackedDirectoryFiles(canonicalRepoRoot, relativeSourceDir, targetPath);
+        if (!copiedAny) {
+            return { source: sourceAsset.source, status: 'missing' };
+        }
+        return {
+            source: sourceAsset.source,
+            status: targetAlreadyExisted ? 'kept-existing' : 'copied',
+        };
+    }
+    copyClaudeDirectoryWithFallback(businessSourcePath, commonSourcePath, targetPath) {
+        const fromBusiness = this.copyClaudeDirectoryFromSingleSource(businessSourcePath, 'business', targetPath);
+        if (fromBusiness) {
+            return fromBusiness;
+        }
+        const fromCommon = this.copyClaudeDirectoryFromSingleSource(commonSourcePath, 'common', targetPath);
+        if (fromCommon) {
+            return fromCommon;
+        }
+        return { source: 'none', status: 'missing' };
+    }
+    copyClaudeDirectoryFromSingleSource(sourcePath, sourceLabel, targetPath) {
+        if (!sourcePath || !existsSync(sourcePath)) {
+            return null;
+        }
+        if (!this.directoryHasAtLeastOneFile(sourcePath)) {
+            return null;
+        }
+        return this.copyClaudeDirectoryIfNeeded({ source: sourceLabel, path: sourcePath }, targetPath);
+    }
+    directoryHasAtLeastOneFile(dirPath) {
+        if (!existsSync(dirPath)) {
+            return false;
+        }
+        try {
+            const entries = readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isFile()) {
+                    return true;
+                }
+                if (entry.isDirectory() && this.directoryHasAtLeastOneFile(fullPath)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+    copyClaudeDirectoryByFileSystem(sourceAsset, targetPath) {
+        if (!existsSync(targetPath)) {
+            cpSync(sourceAsset.path, targetPath, { recursive: true, force: true });
+            return { source: sourceAsset.source, status: 'copied' };
+        }
+        this.mergeDirectoryWithoutOverwrite(sourceAsset.path, targetPath);
+        return { source: sourceAsset.source, status: 'kept-existing' };
+    }
+    findGitRootForPath(sourcePath) {
+        try {
+            const output = execSync('git rev-parse --show-toplevel', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                cwd: sourcePath,
+            });
+            return output.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    safeRealpath(targetPath) {
+        try {
+            return realpathSync(targetPath);
+        }
+        catch {
+            return targetPath;
+        }
+    }
+    copyGitTrackedDirectoryFiles(gitRoot, sourceDirRelativeToGitRoot, targetDir) {
+        try {
+            const sourcePrefix = sourceDirRelativeToGitRoot.endsWith('/')
+                ? sourceDirRelativeToGitRoot
+                : `${sourceDirRelativeToGitRoot}/`;
+            const output = execSync(`git ls-tree -r --name-only HEAD -- "${sourceDirRelativeToGitRoot}"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                cwd: gitRoot,
+            });
+            const trackedFiles = output
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            if (trackedFiles.length === 0) {
+                return false;
+            }
+            mkdirSync(targetDir, { recursive: true });
+            trackedFiles.forEach((repoFilePath) => {
+                const relativePath = repoFilePath.startsWith(sourcePrefix)
+                    ? repoFilePath.slice(sourcePrefix.length)
+                    : path.basename(repoFilePath);
+                const targetFilePath = path.join(targetDir, relativePath);
+                if (existsSync(targetFilePath)) {
+                    return;
+                }
+                mkdirSync(path.dirname(targetFilePath), { recursive: true });
+                const content = execSync(`git show HEAD:${repoFilePath}`, {
+                    encoding: 'buffer',
+                    stdio: ['pipe', 'pipe', 'ignore'],
+                    cwd: gitRoot,
+                });
+                writeFileSync(targetFilePath, content);
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    mergeDirectoryWithoutOverwrite(sourceDir, targetDir) {
+        if (!existsSync(sourceDir) || !existsSync(targetDir)) {
+            return;
+        }
+        const copyRecursive = (source, target) => {
+            const entries = readdirSync(source, { withFileTypes: true });
+            for (const entry of entries) {
+                const sourceEntryPath = path.join(source, entry.name);
+                const targetEntryPath = path.join(target, entry.name);
+                if (entry.isDirectory()) {
+                    mkdirSync(targetEntryPath, { recursive: true });
+                    copyRecursive(sourceEntryPath, targetEntryPath);
+                    continue;
+                }
+                if (!existsSync(targetEntryPath)) {
+                    cpSync(sourceEntryPath, targetEntryPath, { force: false });
+                }
+            }
+        };
+        copyRecursive(sourceDir, targetDir);
+    }
+    describeClaudeAssetResult(assetName, result) {
+        if (result.status === 'missing') {
+            return `${assetName} 未找到可用模板`;
+        }
+        const sourceText = result.source === 'business' ? '业务目录' : 'common/claude';
+        if (result.status === 'kept-existing') {
+            return `${assetName} 使用${sourceText}模板，目标已存在未覆盖`;
+        }
+        return `${assetName} 已从${sourceText}模板复制`;
+    }
     async writeTemplateFiles(zhuanspecPath, config, skipExisting) {
         const context = {};
         const templates = TemplateManager.getTemplates(context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",
@@ -38,6 +38,26 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "node build.js",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/zhuanspec.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:postinstall": "node scripts/postinstall.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
+    "changeset": "changeset"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -59,23 +79,5 @@
     "ora": "^8.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "node build.js",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/zhuanspec.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
-    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
-    "changeset": "changeset"
   }
-}
+}