skill-any-code 1.0.0 → 1.0.1

package/dist/adapters/command.schemas.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectCodeQuerySkillSchema = exports.AnalyzeProjectCommandSchema = void 0;
+const zod_1 = require("zod");
+exports.AnalyzeProjectCommandSchema = zod_1.z.object({
+    path: zod_1.z.string().optional().describe('Project root path to analyze (default: current working directory)'),
+    mode: zod_1.z.enum(['full', 'incremental', 'auto']).default('auto').describe('Analysis mode'),
+    depth: zod_1.z.number().int().min(1).optional().describe('Max directory depth (-1 = unlimited)'),
+    concurrency: zod_1.z.number().int().min(1).optional().describe('Max concurrency (default: CPU cores * 2)'),
+    outputDir: zod_1.z.string().optional().describe('Output directory for analysis results'),
+    skillsProviders: zod_1.z.array(zod_1.z.string()).optional().describe('AI tool providers to deploy the skill to'),
+    noSkills: zod_1.z.boolean().optional().describe('Skip skill generation')
+});
+exports.ProjectCodeQuerySkillSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('Relative path of the file/directory from the project root'),
+    type: zod_1.z.enum(['summary', 'full', 'diagram']).default('summary').describe('Query type'),
+    projectSlug: zod_1.z.string().optional().describe('Project identifier (default: current project)')
+});

package/dist/application/analysis.app.service.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalysisAppService = void 0;
+const git_service_1 = require("../infrastructure/git.service");
+const storage_service_1 = require("../infrastructure/storage.service");
+const blacklist_service_1 = require("../infrastructure/blacklist.service");
+const skill_generator_1 = require("../infrastructure/skill/skill.generator");
+const analysis_service_1 = require("../domain/services/analysis.service");
+const utils_1 = require("../common/utils");
+const errors_1 = require("../common/errors");
+const constants_1 = require("../common/constants");
+const logger_1 = require("../common/logger");
+const fs = __importStar(require("fs-extra"));
+const crypto_1 = require("crypto");
+class AnalysisAppService {
+    totalObjects = 0;
+    completedObjects = 0;
+    activeObjects = new Set();
+    progressEnabled = false;
+    onProgress;
+    concurrency = constants_1.DEFAULT_CONCURRENCY;
+    lastRenderedCurrentKey = null;
+    async runAnalysis(params) {
+        const projectRoot = params.path || process.cwd();
+        logger_1.logger.info(`Analysis started. Project root: ${projectRoot}`);
+        this.progressEnabled = typeof params.onProgress === 'function';
+        this.onProgress = params.onProgress;
+        this.concurrency = params.concurrency || constants_1.DEFAULT_CONCURRENCY;
+        this.totalObjects = 0;
+        this.completedObjects = 0;
+        this.activeObjects = new Set();
+        this.lastRenderedCurrentKey = null;
+        const outputDir = params.outputDir;
+        const gitService = new git_service_1.GitService(projectRoot);
+        const storageService = new storage_service_1.LocalStorageService(projectRoot, outputDir);
+        // 检测是否为Git项目
+        const isGit = await gitService.isGitProject();
+        let projectSlug;
+        let currentCommit = '';
+        let currentBranch = '';
+        logger_1.logger.debug(`Project path: ${projectRoot}, isGit: ${isGit}`);
+        if (isGit) {
+            currentCommit = await gitService.getCurrentCommit();
+            currentBranch = await gitService.getCurrentBranch();
+            const gitSlug = await gitService.getProjectSlug();
+            projectSlug = (0, utils_1.generateProjectSlug)(projectRoot, true, gitSlug);
+            logger_1.logger.debug(`Git info: branch=${currentBranch}, commit=${currentCommit}, slug=${gitSlug}`);
+        }
+        else {
+            projectSlug = (0, utils_1.generateProjectSlug)(projectRoot, false);
+        }
+        // 检测解析模式
+        let mode = params.mode === 'full' ? 'full' : 'incremental';
+        if (params.mode === 'auto') {
+            const hasAnyResult = await storageService.hasAnyResult(projectSlug);
+            mode = hasAnyResult ? 'incremental' : 'full';
+            logger_1.logger.debug(`Auto mode detection: hasAnyResult=${hasAnyResult}, selected=${mode}`);
+        }
+        logger_1.logger.info(`Analysis mode: ${mode}`);
+        let runConfig;
+        try {
+            const { configManager } = await Promise.resolve().then(() => __importStar(require('../common/config')));
+            runConfig = configManager.getConfig();
+        }
+        catch {
+            const { configManager } = await Promise.resolve().then(() => __importStar(require('../common/config')));
+            runConfig = await configManager.load();
+        }
+        const blacklistService = new blacklist_service_1.BlacklistService();
+        await blacklistService.load(runConfig.analyze.blacklist, projectRoot);
+        const llmConfig = params.llmConfig;
+        const storageRoot = (0, utils_1.getStoragePath)(projectRoot, outputDir);
+        if (!params.noSkills) {
+            try {
+                const skillGenerator = new skill_generator_1.SkillGenerator();
+                const providers = (params.skillsProviders ?? runConfig.skills.default_providers);
+                await skillGenerator.generate({ projectRoot, storageRoot, providers });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger_1.logger.warn(`Skill generation failed: ${msg}`);
+            }
+        }
+        const analysisService = new analysis_service_1.AnalysisService(gitService, storageService, blacklistService, projectSlug, currentCommit, llmConfig, params.onTokenUsageSnapshot);
+        const startTime = Date.now();
+        // ===================================================================
+        // 构建文件过滤器（全量 vs 增量唯一的差异点）
+        // ===================================================================
+        let fileFilter;
+        let commitHash = currentCommit;
+        if (mode === 'full') {
+            // 全量：所有文件均需解析
+            fileFilter = async () => true;
+        }
+        else {
+            // 增量：优先对比 commitId，不可用时 fallback 到内容 hash
+            const lastCommit = null;
+            logger_1.logger.debug(`Last analyzed commit: ${lastCommit || 'N/A'}`);
+            // Git 项目：使用 git diff 批量获取变更文件集合（等价于逐文件 commitId 对比的批量优化）
+            let gitChangedFiles = null;
+            if (isGit && lastCommit) {
+                try {
+                    const diffFiles = await gitService.diffCommits(lastCommit, currentCommit);
+                    logger_1.logger.debug(`git diff detected changed files: ${diffFiles.length}`);
+                    gitChangedFiles = new Set(diffFiles);
+                    // 将未提交变更也纳入候选集合
+                    const uncommitted = await gitService.getUncommittedChanges();
+                    if (uncommitted.length > 0) {
+                        logger_1.logger.debug(`Incremental mode detected uncommitted changes: ${uncommitted.length}`);
+                        for (const f of uncommitted)
+                            gitChangedFiles.add(f);
+                    }
+                    logger_1.logger.debug(`Merged changed files count: ${gitChangedFiles.size}`);
+                }
+                catch (e) {
+                    logger_1.logger.warn(`Commit diff failed; falling back to hash comparison: ${e.message}`);
+                }
+            }
+            // 非 Git 项目：需要逐文件 hash 对比，预先无法批量确定变更集
+            // 直接在 filter 内逐文件处理
+            fileFilter = async (relPath, absPath) => {
+                // 检查已有结果是否存在
+                const existing = await storageService.getFileAnalysis(projectSlug, relPath, 'summary');
+                if (!existing)
+                    return true; // 结果缺失 → 需要解析
+                if (isGit) {
+                    if (gitChangedFiles !== null) {
+                        // 批量优化：git diff 隐式对比了 commitId
+                        return gitChangedFiles.has(relPath);
+                    }
+                    // git diff 不可用，回退到逐文件 commitId 对比
+                    const currentFileCommitId = await gitService.getFileLastCommit(projectRoot, relPath);
+                    if (currentFileCommitId && existing.fileGitCommitId) {
+                        return currentFileCommitId !== existing.fileGitCommitId;
+                    }
+                }
+                // 非 Git 或 commitId 不可用：回退到内容 hash 对比
+                if (existing.fileHashWhenAnalyzed) {
+                    const content = await fs.readFile(absPath, 'utf-8');
+                    const currentHash = (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+                    return existing.fileHashWhenAnalyzed !== currentHash;
+                }
+                return true; // 无法判断 → 安全起见重新解析
+            };
+        }
+        // ===================================================================
+        // 调用统一解析管线
+        // ===================================================================
+        logger_1.logger.debug(`Analysis params: depth=${params.depth}, concurrency=${params.concurrency || constants_1.DEFAULT_CONCURRENCY}`);
+        const analysisResult = await analysisService.analyze({
+            projectRoot,
+            depth: params.depth,
+            concurrency: params.concurrency || constants_1.DEFAULT_CONCURRENCY,
+            mode,
+            commitHash,
+            fileFilter,
+            onTotalKnown: (total) => {
+                this.totalObjects = total;
+                params.onTotalKnown?.(total);
+            },
+            onObjectPlanned: obj => this.handleObjectPlanned(obj),
+            onObjectStarted: obj => this.handleObjectStarted(obj),
+            onObjectCompleted: (obj, meta) => this.handleObjectCompleted(obj, meta, params),
+            onScanProgress: params.onScanProgress,
+        });
+        const duration = Date.now() - startTime;
+        const summaryPath = analysisResult.summaryPath;
+        const tokenUsage = analysisService.getTokenUsage();
+        return {
+            success: analysisResult.success,
+            code: analysisResult.success ? errors_1.ErrorCode.SUCCESS : errors_1.ErrorCode.ANALYSIS_EXCEPTION,
+            message: analysisResult.success ? 'Analysis completed' : `Analysis completed with ${analysisResult.errors.length} error(s)`,
+            data: {
+                projectName: projectSlug,
+                mode,
+                analyzedFilesCount: analysisResult.analyzedFilesCount,
+                duration,
+                summaryPath,
+                tokenUsage,
+            },
+            errors: analysisResult.errors.length > 0 ? analysisResult.errors : undefined
+        };
+    }
+    handleObjectPlanned(_obj) {
+        // totalObjects 由 analyze 内部的 onTotalKnown 回调设置
+    }
+    handleObjectStarted(obj) {
+        if (!this.progressEnabled)
+            return;
+        const normalized = this.normalizeObjectPath(obj);
+        this.activeObjects.add(normalized);
+        this.emitProgressSnapshot(new Set(this.activeObjects), normalized);
+    }
+    handleObjectCompleted(obj, _meta, params) {
+        this.completedObjects++;
+        if (!this.progressEnabled) {
+            return;
+        }
+        const normalized = this.normalizeObjectPath(obj);
+        this.activeObjects.delete(normalized);
+        this.concurrency = params.concurrency || constants_1.DEFAULT_CONCURRENCY;
+        this.emitProgressSnapshot(new Set(this.activeObjects), normalized);
+    }
+    normalizeObjectPath(obj) {
+        const p = obj.path.replace(/\\/g, '/');
+        if (obj.type === 'directory') {
+            if (p === '.')
+                return './';
+            return p.endsWith('/') ? p : `${p}/`;
+        }
+        return p;
+    }
+    emitProgressSnapshot(snapshot, fallbackNormalized) {
+        if (!this.onProgress)
+            return;
+        const activePaths = Array.from(snapshot)
+            .map(p => p.replace(/\\/g, '/'))
+            .sort();
+        const topN = activePaths.slice(0, this.concurrency);
+        const displayLines = topN;
+        const key = displayLines.join('\n');
+        if (key === this.lastRenderedCurrentKey) {
+            return;
+        }
+        this.lastRenderedCurrentKey = key;
+        this.onProgress(this.completedObjects, this.totalObjects, {
+            path: key,
+        });
+    }
+}
+exports.AnalysisAppService = AnalysisAppService;

package/dist/application/bootstrap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppServices = createAppServices;
+const analysis_app_service_1 = require("./analysis.app.service");
+const git_service_1 = require("../infrastructure/git.service");
+const storage_service_1 = require("../infrastructure/storage.service");
+const incremental_service_1 = require("../domain/services/incremental.service");
+function createAppServices(projectRoot, llmConfig, onTokenUsageSnapshot) {
+    const root = projectRoot || process.cwd();
+    const gitService = new git_service_1.GitService(root);
+    const storageService = new storage_service_1.LocalStorageService(root);
+    const incrementalService = new incremental_service_1.IncrementalService(gitService, storageService);
+    const analysisAppService = new analysis_app_service_1.AnalysisAppService();
+    return {
+        analysisAppService,
+        analysisService: {},
+        incrementalService,
+        gitService,
+        storageService,
+    };
+}

package/dist/application/services/llm.analysis.service.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMAnalysisService = void 0;
+const prompt_template_1 = require("../../infrastructure/llm/prompt.template");
+const mustache_1 = __importDefault(require("mustache"));
+const errors_1 = require("../../common/errors");
+const path_1 = __importDefault(require("path"));
+/** 从 LLM 返回中解析单字段：支持 {"key": "value"} 或纯字符串 */
+function parseSingleField(content, field) {
+    const trimmed = content.trim();
+    try {
+        const o = JSON.parse(trimmed);
+        if (o && typeof o[field] === 'string')
+            return o[field];
+    }
+    catch {
+        // 非 JSON 则整体视为该字段内容
+    }
+    return trimmed || '';
+}
+class LLMAnalysisService {
+    llmClient;
+    fileSplitter;
+    cache;
+    config;
+    constructor(llmClient, fileSplitter, cache, config) {
+        this.llmClient = llmClient;
+        this.fileSplitter = fileSplitter;
+        this.cache = cache;
+        this.config = config;
+    }
+    async analyzeFile(filePath, fileContent, fileHash) {
+        // 先查缓存
+        if (this.config.cache_enabled) {
+            const cachedResult = await this.cache.get(fileHash);
+            if (cachedResult) {
+                cachedResult.path = filePath;
+                cachedResult.lastAnalyzedAt = new Date().toISOString();
+                return cachedResult;
+            }
+        }
+        let result;
+        // 检查文件大小是否超过上下文窗口
+        if (fileContent.length > this.config.context_window_size * 0.8) {
+            // 大文件分片解析
+            result = await this.analyzeLargeFile(filePath, fileContent);
+        }
+        else {
+            // 小文件直接解析
+            result = await this.analyzeSmallFile(filePath, fileContent);
+        }
+        // 保存缓存
+        if (this.config.cache_enabled) {
+            await this.cache.set(fileHash, result);
+        }
+        result.path = filePath;
+        result.lastAnalyzedAt = new Date().toISOString();
+        return result;
+    }
+    /** 三步协议（需求 10.5.3 / 10.9.1）：结构 → 功能描述 → 概述，程序组装为完整 FileAnalysis；某次解析失败仅重试当次（10.9.2）。 */
+    async analyzeSmallFile(filePath, fileContent) {
+        const opts = { temperature: 0.1 };
+        // 第一步：仅提取结构（classes / globalVariables / globalFunctions），不包含基础信息
+        const structure = await this.callWithParseRetry(mustache_1.default.render(prompt_template_1.FILE_STRUCTURE_PROMPT, { filePath, fileContent }), opts, (content) => {
+            const o = JSON.parse(content);
+            return {
+                classes: Array.isArray(o.classes) ? o.classes : [],
+                functions: Array.isArray(o.functions) ? o.functions : []
+            };
+        });
+        const structureJson = JSON.stringify(structure, null, 2);
+        // 第二步：仅生成功能描述
+        const description = await this.callWithParseRetry(mustache_1.default.render(prompt_template_1.FILE_DESCRIPTION_PROMPT, { structureJson }), opts, (content) => parseSingleField(content, 'description'));
+        // 第三步：仅生成概述
+        const summary = await this.callWithParseRetry(mustache_1.default.render(prompt_template_1.FILE_SUMMARY_PROMPT, { structureJson, description }), opts, (content) => parseSingleField(content, 'summary'));
+        // 基础信息由程序侧负责（设计文档 13.2.2）
+        const name = path_1.default.basename(filePath);
+        const language = this.detectLanguage(filePath);
+        const linesOfCode = fileContent.split(/\r?\n/).length;
+        return {
+            type: 'file',
+            path: filePath,
+            name,
+            language,
+            linesOfCode,
+            dependencies: [],
+            description,
+            summary,
+            classes: structure.classes,
+            functions: structure.functions,
+            lastAnalyzedAt: new Date().toISOString(),
+            commitHash: ''
+        };
+    }
+    detectLanguage(filePath) {
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        switch (ext) {
+            case '.ts':
+            case '.tsx':
+                return 'TypeScript';
+            case '.js':
+            case '.jsx':
+                return 'JavaScript';
+            case '.py':
+                return 'Python';
+            case '.java':
+                return 'Java';
+            case '.go':
+                return 'Go';
+            case '.cs':
+                return 'C#';
+            default:
+                return '';
+        }
+    }
+    /** 单次调用：解析失败则仅重试该次一次，不重做已成功步骤（需求 10.9.2）。 */
+    async callWithParseRetry(prompt, options, parseFn) {
+        let lastError;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const response = await this.llmClient.call(attempt === 1 ? prompt + prompt_template_1.PARSE_RETRY_HINT : prompt, { ...options, retries: 0 });
+                return parseFn(response.content);
+            }
+            catch (e) {
+                lastError = e;
+            }
+        }
+        throw new errors_1.AppError(errors_1.ErrorCode.LLM_RESPONSE_PARSE_FAILED, `Failed to parse LLM response after retry: ${lastError?.message}`, lastError);
+    }
+    async analyzeLargeFile(filePath, fileContent) {
+        // 分片
+        const chunks = await this.fileSplitter.split(fileContent, this.config.context_window_size * 0.7);
+        // 并行解析所有分片（仅提取结构）
+        const chunkAnalysisPromises = chunks.map(async (chunk) => {
+            const prompt = mustache_1.default.render(prompt_template_1.CHUNK_ANALYSIS_PROMPT, {
+                filePath,
+                chunkId: chunk.id,
+                chunkContent: chunk.content,
+                context: chunk.context || ''
+            });
+            const response = await this.llmClient.call(prompt, { temperature: 0.1 });
+            const parsed = JSON.parse(response.content);
+            return {
+                chunkId: chunk.id,
+                classes: Array.isArray(parsed.classes) ? parsed.classes : [],
+                functions: Array.isArray(parsed.functions) ? parsed.functions : []
+            };
+        });
+        const chunkResults = await Promise.all(chunkAnalysisPromises);
+        // 合并分片结果
+        return this.fileSplitter.merge(chunkResults, filePath);
+    }
+    /**
+     * 目录两步协议（需求 10.6.3 / 10.9.3）：基于子项精简信息先生成 description，再生成 summary。
+     */
+    async analyzeDirectory(childrenDirs, childrenFiles) {
+        const opts = { temperature: 0.1 };
+        const payload = { childrenDirs, childrenFiles };
+        const childrenJson = JSON.stringify(payload, null, 2);
+        // 第一步：功能描述
+        const description = await this.callWithParseRetry(mustache_1.default.render(prompt_template_1.DIRECTORY_DESCRIPTION_PROMPT, { childrenJson }), opts, (content) => parseSingleField(content, 'description'));
+        // 第二步：概述
+        const summary = await this.callWithParseRetry(mustache_1.default.render(prompt_template_1.DIRECTORY_SUMMARY_PROMPT, { description, childrenJson }), opts, (content) => parseSingleField(content, 'summary'));
+        return { description, summary };
+    }
+}
+exports.LLMAnalysisService = LLMAnalysisService;