skill-any-code 1.0.0

package/src/application/analysis.app.service.ts

@@ -0,0 +1,272 @@
+import {
+  AnalyzeProjectCommandParams,
+  AnalyzeProjectCommandResult,
+  LLMConfig,
+  AnalysisObject,
+  ObjectResultMeta,
+} from '../common/types'
+import { GitService } from '../infrastructure/git.service'
+import { LocalStorageService } from '../infrastructure/storage.service'
+import { BlacklistService } from '../infrastructure/blacklist.service'
+import { SkillGenerator } from '../infrastructure/skill/skill.generator'
+import { AnalysisService } from '../domain/services/analysis.service'
+import { generateProjectSlug, getStoragePath, getFileOutputPath } from '../common/utils'
+import { AppError, ErrorCode } from '../common/errors'
+import { DEFAULT_CONCURRENCY } from '../common/constants'
+import { logger } from '../common/logger'
+import type { SkillProvider } from '../domain/interfaces'
+import type { Config } from '../common/config'
+import * as path from 'path'
+import * as fs from 'fs-extra'
+import { createHash } from 'crypto'
+import { OpenAIClient } from '../infrastructure/llm/openai.client'
+
+export class AnalysisAppService {
+  private totalObjects = 0
+  private completedObjects = 0
+  private activeObjects: Set<string> = new Set()
+  private progressEnabled = false
+  private onProgress?: AnalyzeProjectCommandParams['onProgress']
+  private concurrency = DEFAULT_CONCURRENCY
+  private lastRenderedCurrentKey: string | null = null
+
+  async runAnalysis(params: AnalyzeProjectCommandParams & { outputDir?: string }): Promise<AnalyzeProjectCommandResult> {
+    const projectRoot = params.path || process.cwd()
+    logger.info(`Analysis started. Project root: ${projectRoot}`)
+    this.progressEnabled = typeof params.onProgress === 'function'
+    this.onProgress = params.onProgress
+    this.concurrency = params.concurrency || DEFAULT_CONCURRENCY
+    this.totalObjects = 0
+    this.completedObjects = 0
+    this.activeObjects = new Set()
+    this.lastRenderedCurrentKey = null
+    const outputDir = params.outputDir
+    const gitService = new GitService(projectRoot)
+    const storageService = new LocalStorageService(projectRoot, outputDir)
+
+    // 检测是否为Git项目
+    const isGit = await gitService.isGitProject()
+    let projectSlug: string
+    let currentCommit = ''
+    let currentBranch = ''
+    logger.debug(`Project path: ${projectRoot}, isGit: ${isGit}`)
+
+    if (isGit) {
+      currentCommit = await gitService.getCurrentCommit()
+      currentBranch = await gitService.getCurrentBranch()
+      const gitSlug = await gitService.getProjectSlug()
+      projectSlug = generateProjectSlug(projectRoot, true, gitSlug)
+      logger.debug(`Git info: branch=${currentBranch}, commit=${currentCommit}, slug=${gitSlug}`)
+    } else {
+      projectSlug = generateProjectSlug(projectRoot, false)
+    }
+
+    // 检测解析模式
+    let mode: 'full' | 'incremental' = params.mode === 'full' ? 'full' : 'incremental'
+    if (params.mode === 'auto') {
+      const hasAnyResult = await storageService.hasAnyResult(projectSlug)
+      mode = hasAnyResult ? 'incremental' : 'full'
+      logger.debug(
+        `Auto mode detection: hasAnyResult=${hasAnyResult}, selected=${mode}`,
+      )
+    }
+    logger.info(`Analysis mode: ${mode}`)
+
+    let runConfig: Config
+    try {
+      const { configManager } = await import('../common/config')
+      runConfig = configManager.getConfig()
+    } catch {
+      const { configManager } = await import('../common/config')
+      runConfig = await configManager.load()
+    }
+    const blacklistService = new BlacklistService()
+    await blacklistService.load(runConfig.analyze.blacklist, projectRoot)
+    const llmConfig = params.llmConfig as LLMConfig
+    const storageRoot = getStoragePath(projectRoot, outputDir)
+
+    if (!params.noSkills) {
+      try {
+        const skillGenerator = new SkillGenerator()
+        const providers = (params.skillsProviders ?? runConfig.skills.default_providers) as SkillProvider[]
+        await skillGenerator.generate({ projectRoot, storageRoot, providers })
+      } catch (error: unknown) {
+        const msg = error instanceof Error ? error.message : String(error)
+        logger.warn(`Skill generation failed: ${msg}`)
+      }
+    }
+
+    const analysisService = new AnalysisService(
+      gitService,
+      storageService,
+      blacklistService,
+      projectSlug,
+      currentCommit,
+      llmConfig,
+      params.onTokenUsageSnapshot,
+    )
+
+    const startTime = Date.now()
+
+    // ===================================================================
+    // 构建文件过滤器（全量 vs 增量唯一的差异点）
+    // ===================================================================
+    let fileFilter: (relPath: string, absPath: string) => Promise<boolean>
+    let commitHash: string = currentCommit
+
+    if (mode === 'full') {
+      // 全量：所有文件均需解析
+      fileFilter = async () => true
+    } else {
+      // 增量：优先对比 commitId，不可用时 fallback 到内容 hash
+      const lastCommit = null
+      logger.debug(`Last analyzed commit: ${lastCommit || 'N/A'}`)
+
+      // Git 项目：使用 git diff 批量获取变更文件集合（等价于逐文件 commitId 对比的批量优化）
+      let gitChangedFiles: Set<string> | null = null
+      if (isGit && lastCommit) {
+        try {
+          const diffFiles = await gitService.diffCommits(lastCommit, currentCommit)
+          logger.debug(`git diff detected changed files: ${diffFiles.length}`)
+          gitChangedFiles = new Set(diffFiles)
+
+          // 将未提交变更也纳入候选集合
+          const uncommitted = await gitService.getUncommittedChanges()
+          if (uncommitted.length > 0) {
+            logger.debug(`Incremental mode detected uncommitted changes: ${uncommitted.length}`)
+            for (const f of uncommitted) gitChangedFiles.add(f)
+          }
+          logger.debug(`Merged changed files count: ${gitChangedFiles.size}`)
+        } catch (e) {
+          logger.warn(`Commit diff failed; falling back to hash comparison: ${(e as Error).message}`)
+        }
+      }
+
+      // 非 Git 项目：需要逐文件 hash 对比，预先无法批量确定变更集
+      // 直接在 filter 内逐文件处理
+
+      fileFilter = async (relPath: string, absPath: string): Promise<boolean> => {
+        // 检查已有结果是否存在
+        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 = createHash('sha256').update(content).digest('hex')
+          return existing.fileHashWhenAnalyzed !== currentHash
+        }
+
+        return true // 无法判断 → 安全起见重新解析
+      }
+    }
+
+    // ===================================================================
+    // 调用统一解析管线
+    // ===================================================================
+    logger.debug(`Analysis params: depth=${params.depth}, concurrency=${params.concurrency || DEFAULT_CONCURRENCY}`)
+    const analysisResult = await analysisService.analyze({
+      projectRoot,
+      depth: params.depth,
+      concurrency: params.concurrency || 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 ? ErrorCode.SUCCESS : 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
+    }
+  }
+
+  private handleObjectPlanned(_obj: AnalysisObject): void {
+    // totalObjects 由 analyze 内部的 onTotalKnown 回调设置
+  }
+
+  private handleObjectStarted(obj: AnalysisObject): void {
+    if (!this.progressEnabled) return
+    const normalized = this.normalizeObjectPath(obj)
+    this.activeObjects.add(normalized)
+    this.emitProgressSnapshot(new Set(this.activeObjects), normalized)
+  }
+
+  private handleObjectCompleted(
+    obj: AnalysisObject,
+    _meta: ObjectResultMeta,
+    params: AnalyzeProjectCommandParams,
+  ): void {
+    this.completedObjects++
+    if (!this.progressEnabled) {
+      return
+    }
+
+    const normalized = this.normalizeObjectPath(obj)
+    this.activeObjects.delete(normalized)
+    this.concurrency = params.concurrency || DEFAULT_CONCURRENCY
+    this.emitProgressSnapshot(new Set(this.activeObjects), normalized)
+  }
+
+  private normalizeObjectPath(obj: AnalysisObject): string {
+    const p = obj.path.replace(/\\/g, '/')
+    if (obj.type === 'directory') {
+      if (p === '.') return './'
+      return p.endsWith('/') ? p : `${p}/`
+    }
+    return p
+  }
+
+  private emitProgressSnapshot(snapshot: Set<string>, fallbackNormalized: string): void {
+    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,
+    })
+  }
+}

package/src/application/bootstrap.ts

@@ -0,0 +1,35 @@
+import { AnalysisAppService } from './analysis.app.service'
+import { GitService } from '../infrastructure/git.service'
+import { LocalStorageService } from '../infrastructure/storage.service'
+import { AnalysisService } from '../domain/services/analysis.service'
+import { IncrementalService } from '../domain/services/incremental.service'
+import type { LLMConfig, TokenUsageStats } from '../common/types'
+
+export interface AppServices {
+  analysisAppService: AnalysisAppService
+  analysisService: AnalysisService
+  incrementalService: IncrementalService
+  gitService: GitService
+  storageService: LocalStorageService
+}
+
+export function createAppServices(
+  projectRoot?: string,
+  llmConfig?: LLMConfig,
+  onTokenUsageSnapshot?: (stats: TokenUsageStats) => void,
+): AppServices {
+  const root = projectRoot || process.cwd()
+  const gitService = new GitService(root)
+  const storageService = new LocalStorageService(root)
+  const incrementalService = new IncrementalService(gitService, storageService)
+
+  const analysisAppService = new AnalysisAppService()
+
+  return {
+    analysisAppService,
+    analysisService: {} as AnalysisService,
+    incrementalService,
+    gitService,
+    storageService,
+  }
+}

package/src/application/services/llm.analysis.service.ts

@@ -0,0 +1,237 @@
+import type { ILLMClient, IFileSplitter, IAnalysisCache } from '../../domain/interfaces';
+import type { FileAnalysis, LLMConfig, FileChunkAnalysis } from '../../common/types';
+import {
+  FILE_STRUCTURE_PROMPT,
+  FILE_DESCRIPTION_PROMPT,
+  FILE_SUMMARY_PROMPT,
+  PARSE_RETRY_HINT,
+  CHUNK_ANALYSIS_PROMPT,
+  DIRECTORY_DESCRIPTION_PROMPT,
+  DIRECTORY_SUMMARY_PROMPT
+} from '../../infrastructure/llm/prompt.template';
+import Mustache from 'mustache';
+import { AppError, ErrorCode } from '../../common/errors';
+import { FileHashCache } from '../../infrastructure/cache/file.hash.cache';
+import path from 'path';
+
+/** 从 LLM 返回中解析单字段：支持 {"key": "value"} 或纯字符串 */
+function parseSingleField(content: string, field: 'description' | 'summary'): string {
+  const trimmed = content.trim();
+  try {
+    const o = JSON.parse(trimmed);
+    if (o && typeof o[field] === 'string') return o[field];
+  } catch {
+    // 非 JSON 则整体视为该字段内容
+  }
+  return trimmed || '';
+}
+
+export class LLMAnalysisService {
+  private llmClient: ILLMClient;
+  private fileSplitter: IFileSplitter;
+  private cache: IAnalysisCache;
+  private config: LLMConfig;
+
+  constructor(
+    llmClient: ILLMClient,
+    fileSplitter: IFileSplitter,
+    cache: IAnalysisCache,
+    config: LLMConfig
+  ) {
+    this.llmClient = llmClient;
+    this.fileSplitter = fileSplitter;
+    this.cache = cache;
+    this.config = config;
+  }
+
+  async analyzeFile(filePath: string, fileContent: string, fileHash: string): Promise<FileAnalysis> {
+    // 先查缓存
+    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: FileAnalysis;
+
+    // 检查文件大小是否超过上下文窗口
+    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）。 */
+  private async analyzeSmallFile(filePath: string, fileContent: string): Promise<FileAnalysis> {
+    const opts = { temperature: 0.1 };
+
+    // 第一步：仅提取结构（classes / globalVariables / globalFunctions），不包含基础信息
+    const structure = await this.callWithParseRetry(
+      Mustache.render(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.render(FILE_DESCRIPTION_PROMPT, { structureJson }),
+      opts,
+      (content) => parseSingleField(content, 'description')
+    );
+
+    // 第三步：仅生成概述
+    const summary = await this.callWithParseRetry(
+      Mustache.render(FILE_SUMMARY_PROMPT, { structureJson, description }),
+      opts,
+      (content) => parseSingleField(content, 'summary')
+    );
+
+    // 基础信息由程序侧负责（设计文档 13.2.2）
+    const name = path.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: ''
+    };
+  }
+
+  private detectLanguage(filePath: string): string {
+    const ext = path.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）。 */
+  private async callWithParseRetry<T>(
+    prompt: string,
+    options: { temperature?: number },
+    parseFn: (content: string) => T
+  ): Promise<T> {
+    let lastError: unknown;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const response = await this.llmClient.call(
+          attempt === 1 ? prompt + PARSE_RETRY_HINT : prompt,
+          { ...options, retries: 0 }
+        );
+        return parseFn(response.content);
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw new AppError(
+      ErrorCode.LLM_RESPONSE_PARSE_FAILED,
+      `Failed to parse LLM response after retry: ${(lastError as Error)?.message}`,
+      lastError
+    );
+  }
+
+  private async analyzeLargeFile(filePath: string, fileContent: string): Promise<FileAnalysis> {
+    // 分片
+    const chunks = await this.fileSplitter.split(fileContent, this.config.context_window_size * 0.7);
+    
+    // 并行解析所有分片（仅提取结构）
+    const chunkAnalysisPromises = chunks.map(async (chunk) => {
+      const prompt = Mustache.render(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 : []
+      } as FileChunkAnalysis;
+    });
+
+    const chunkResults = await Promise.all(chunkAnalysisPromises);
+    
+    // 合并分片结果
+    return this.fileSplitter.merge(chunkResults, filePath);
+  }
+
+  /**
+   * 目录两步协议（需求 10.6.3 / 10.9.3）：基于子项精简信息先生成 description，再生成 summary。
+   */
+  async analyzeDirectory(
+    childrenDirs: Array<{ name: string; summary: string; description: string }>,
+    childrenFiles: Array<{ name: string; summary: string; description: string }>
+  ): Promise<{ description: string; summary: string }> {
+    const opts = { temperature: 0.1 };
+    const payload = { childrenDirs, childrenFiles };
+    const childrenJson = JSON.stringify(payload, null, 2);
+
+    // 第一步：功能描述
+    const description = await this.callWithParseRetry(
+      Mustache.render(DIRECTORY_DESCRIPTION_PROMPT, { childrenJson }),
+      opts,
+      (content) => parseSingleField(content, 'description')
+    );
+
+    // 第二步：概述
+    const summary = await this.callWithParseRetry(
+      Mustache.render(DIRECTORY_SUMMARY_PROMPT, { description, childrenJson }),
+      opts,
+      (content) => parseSingleField(content, 'summary')
+    );
+
+    return { description, summary };
+  }
+
+}