skill-any-code 1.0.0 → 1.0.1

package/dist/infrastructure/worker-pool/parse.worker.js

@@ -0,0 +1,43 @@
+"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 });
+const workerpool = __importStar(require("workerpool"));
+const parse_worker_impl_1 = require("./parse.worker.impl");
+// 注册Worker方法
+workerpool.worker({
+    parseFile: parse_worker_impl_1.parseFile,
+    aggregateDirectory: parse_worker_impl_1.aggregateDirectory,
+    validateResult: parse_worker_impl_1.validateResult
+});

package/dist/infrastructure/worker-pool/worker-pool.service.js

@@ -0,0 +1,171 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPoolService = void 0;
+const workerpool = __importStar(require("workerpool"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const errors_1 = require("../../common/errors");
+const constants_1 = require("../../common/constants");
+const os_1 = __importDefault(require("os"));
+const parse_worker_impl_1 = require("./parse.worker.impl");
+class WorkerPoolService {
+    pool;
+    pendingTasks = [];
+    currentConcurrency;
+    llmConfig;
+    localMode;
+    constructor(llmConfig, concurrency = constants_1.DEFAULT_CONCURRENCY) {
+        this.currentConcurrency = concurrency;
+        this.llmConfig = {
+            ...llmConfig,
+            cache_dir: WorkerPoolService.expandTilde(llmConfig.cache_dir),
+        };
+        const workerScript = path.join(__dirname, 'parse.worker.js');
+        this.localMode = !fs.existsSync(workerScript);
+        // Jest/ts-jest 直接执行 src 时，parse.worker.js 不存在。此时回退到“本进程执行”以保证核心逻辑可测。
+        // 生产构建（dist）与 CLI 运行时，parse.worker.js 存在，继续使用 worker threads 提升性能。
+        if (!this.localMode) {
+            this.pool = workerpool.pool(workerScript, {
+                maxWorkers: concurrency,
+                workerType: 'thread',
+            });
+        }
+    }
+    static expandTilde(p) {
+        if (!p)
+            return p;
+        if (p.startsWith('~') && (p.length === 1 || p[1] === '/' || p[1] === '\\')) {
+            return path.join(os_1.default.homedir(), p.slice(1));
+        }
+        return p;
+    }
+    async submitFileAnalysisTask(filePath, fileContent, fileHash, language) {
+        if (this.localMode) {
+            const task = (0, parse_worker_impl_1.parseFile)(filePath, fileContent, fileHash, language, this.llmConfig);
+            this.pendingTasks.push(task);
+            try {
+                return await task;
+            }
+            finally {
+                this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            }
+        }
+        try {
+            const task = this.pool.exec('parseFile', [filePath, fileContent, fileHash, language, this.llmConfig]);
+            this.pendingTasks.push(task);
+            const result = await task;
+            // 移除已完成的任务
+            this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            return result;
+        }
+        catch (e) {
+            throw new errors_1.AppError(errors_1.ErrorCode.WORKER_SCHEDULE_FAILED, 'File analysis task failed', e.message);
+        }
+    }
+    async submitDirectoryAggregationTask(dirPath, payload) {
+        if (this.localMode) {
+            const task = (0, parse_worker_impl_1.aggregateDirectory)(dirPath, payload, this.llmConfig);
+            this.pendingTasks.push(task);
+            try {
+                return await task;
+            }
+            finally {
+                this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            }
+        }
+        try {
+            const task = this.pool.exec('aggregateDirectory', [dirPath, payload, this.llmConfig]);
+            this.pendingTasks.push(task);
+            const result = await task;
+            this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            return result;
+        }
+        catch (e) {
+            throw new errors_1.AppError(errors_1.ErrorCode.WORKER_SCHEDULE_FAILED, 'Directory aggregation task failed', e.message);
+        }
+    }
+    async submitValidationTask(parentResult, childResult) {
+        if (this.localMode) {
+            const task = (0, parse_worker_impl_1.validateResult)(parentResult, childResult);
+            this.pendingTasks.push(task);
+            try {
+                return await task;
+            }
+            finally {
+                this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            }
+        }
+        try {
+            const task = this.pool.exec('validateResult', [parentResult, childResult]);
+            this.pendingTasks.push(task);
+            const result = await task;
+            this.pendingTasks = this.pendingTasks.filter(t => t !== task);
+            return result;
+        }
+        catch (e) {
+            throw new errors_1.AppError(errors_1.ErrorCode.WORKER_SCHEDULE_FAILED, 'Validation task failed', e.message);
+        }
+    }
+    setConcurrency(concurrency) {
+        this.currentConcurrency = concurrency;
+        if (this.localMode) {
+            return;
+        }
+        // 立即终止旧 worker，避免遗留线程占用资源
+        void this.pool.terminate(true).catch(() => { });
+        this.pool = workerpool.pool(path.join(__dirname, 'parse.worker.js'), {
+            maxWorkers: concurrency,
+            workerType: 'thread'
+        });
+    }
+    async waitAll() {
+        await Promise.all(this.pendingTasks);
+    }
+    cancelAll() {
+        void this.pool?.terminate(true).catch(() => { });
+        this.pendingTasks = [];
+    }
+    async terminate(force = true) {
+        if (this.pool) {
+            await this.pool.terminate(force);
+        }
+        this.pendingTasks = [];
+    }
+}
+exports.WorkerPoolService = WorkerPoolService;

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "skill-any-code",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Skill Any Code: CLI tool for large codebase understanding and analysis",
   "main": "dist/index.js",
   "bin": {
     "skill-any-code": "dist/cli.js",
     "sac": "dist/cli.js"
   },
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",

package/jest.config.js

@@ -1,27 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  rootDir: '.',
-  // Windows 下大量文件/子进程/临时目录操作容易触发 EBUSY，串行执行更稳定
-  maxWorkers: 1,
-  testMatch: [
-    '<rootDir>/tests/**/*.test.ts'
-  ],
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
-  transform: {
-    '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.test.json' }]
-  },
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts'
-  ],
-  coverageDirectory: '<rootDir>/tests/coverage',
-  coverageReporters: ['text', 'lcov', 'html'],
-  cacheDirectory: '<rootDir>/tests/.cache/jest',
-  testTimeout: 300000, // 5分钟超时，适配大型项目测试
-  // 旧版 OpenCode/Skill 的测试辅助已废弃（V2.x 使用 CLI + LLM Mock Server）
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/src/$1'
-  }
-};

package/src/adapters/command.schemas.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod'
-
-export const AnalyzeProjectCommandSchema = z.object({
-  path: z.string().optional().describe('Project root path to analyze (default: current working directory)'),
-  mode: z.enum(['full', 'incremental', 'auto']).default('auto').describe('Analysis mode'),
-  depth: z.number().int().min(1).optional().describe('Max directory depth (-1 = unlimited)'),
-  concurrency: z.number().int().min(1).optional().describe('Max concurrency (default: CPU cores * 2)'),
-  outputDir: z.string().optional().describe('Output directory for analysis results'),
-  skillsProviders: z.array(z.string()).optional().describe('AI tool providers to deploy the skill to'),
-  noSkills: z.boolean().optional().describe('Skip skill generation')
-})
-
-export type AnalyzeProjectCommandParams = z.infer<typeof AnalyzeProjectCommandSchema>
-
-export const ProjectCodeQuerySkillSchema = z.object({
-  path: z.string().describe('Relative path of the file/directory from the project root'),
-  type: z.enum(['summary', 'full', 'diagram']).default('summary').describe('Query type'),
-  projectSlug: z.string().optional().describe('Project identifier (default: current project)')
-})
-
-export type ProjectCodeQuerySkillParams = z.infer<typeof ProjectCodeQuerySkillSchema>

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

@@ -1,272 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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,
-  }
-}