skill-any-code 1.0.0

package/src/domain/services/incremental.service.ts

@@ -0,0 +1,50 @@
+import { IIncrementalService, IGitService, IStorageService } from '../interfaces'
+
+export class IncrementalService implements IIncrementalService {
+  constructor(
+    private gitService: IGitService,
+    private storageService: IStorageService
+  ) {}
+
+  async canDoIncremental(projectRoot: string): Promise<{ available: boolean; baseCommit?: string; reason?: string }> {
+    const isGit = await this.gitService.isGitProject(projectRoot)
+    if (!isGit) return { available: false, reason: 'Not a git project' }
+
+    // V2.6：不再生成/读取 .analysis_metadata.json，因此无法基于历史记录计算可用的 baseCommit。
+    // 主流程会回退到逐文件 commitId/hash 判定，无需依赖此服务。
+    return { available: false, reason: 'Metadata disabled (V2.6): fallback to per-file incremental detection' }
+  }
+
+  async getChangedFiles(projectRoot: string, baseCommit: string, targetCommit: string): Promise<string[]> {
+    return this.gitService.diffCommits(projectRoot, baseCommit, targetCommit)
+  }
+
+  async findNearestCommonAncestor(projectRoot: string, commits: string[]): Promise<string | null> {
+    try {
+      const { simpleGit } = await import('simple-git')
+      const git = simpleGit(projectRoot)
+      const commonAncestor = await git.raw(['merge-base', '--octopus', ...commits])
+      return commonAncestor.trim() || null
+    } catch (e) {
+      return null
+    }
+  }
+
+  getAffectedDirectories(changedFiles: string[]): string[] {
+    const directories = new Set<string>()
+    
+    changedFiles.forEach(file => {
+      const parts = file.split('/')
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join('/')
+        if (dir) {
+          directories.add(dir)
+        }
+      }
+    })
+
+    directories.add('')
+
+    return Array.from(directories)
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './common/types'
+export * from './common/errors'
+export * from './domain'
+export * from './application/analysis.app.service'
+export * from './infrastructure/git.service'
+export * from './infrastructure/storage.service'

package/src/infrastructure/blacklist.service.ts

@@ -0,0 +1,37 @@
+import ignore, { Ignore } from 'ignore'
+import * as fs from 'fs-extra'
+import * as path from 'path'
+import { IBlacklistService } from '../domain/interfaces'
+
+export class BlacklistService implements IBlacklistService {
+  private ig: Ignore = ignore()
+
+  async load(globalBlacklist: string[], projectRoot: string): Promise<void> {
+    this.ig = ignore()
+
+    this.ig.add(globalBlacklist)
+
+    const projectIgnorePath = path.join(projectRoot, '.skill-any-code-ignore')
+    if (await fs.pathExists(projectIgnorePath)) {
+      const content = await fs.readFile(projectIgnorePath, 'utf-8')
+      this.ig.add(content)
+    }
+
+    const gitignorePath = path.join(projectRoot, '.gitignore')
+    if (await fs.pathExists(gitignorePath)) {
+      const content = await fs.readFile(gitignorePath, 'utf-8')
+      this.ig.add(content)
+    }
+  }
+
+  isIgnored(relativePath: string): boolean {
+    // 1. 统一为正斜杠（Windows path.relative 可能返回反斜杠）
+    let normalized = relativePath.replace(/\\/g, '/')
+    // 2. 去掉 leading ./ 或 /（ignore 库拒绝此类路径并抛错，见 REGEX_TEST_INVALID_PATH）
+    // path.relative 在部分 Windows 场景下可能返回 ".\" 前缀，归一化后为 "./"，会导致 ignore 库抛出 RangeError
+    normalized = normalized.replace(/^\.\//, '').replace(/^\/+/, '')
+    // ignore 库不接受空字符串路径；空路径表示“项目根自身”，这里视为不忽略
+    if (!normalized) return false
+    return this.ig.ignores(normalized)
+  }
+}

package/src/infrastructure/cache/file.hash.cache.ts

@@ -0,0 +1,119 @@
+import { IAnalysisCache } from '../../domain/interfaces';
+import { FileAnalysis } from '../../common/types';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import { logger } from '../../common/logger';
+
+interface FileHashCacheOptions {
+  cacheDir: string;
+  maxSizeMb: number; // 0 表示禁用（V2.5）
+}
+
+export class FileHashCache implements IAnalysisCache {
+  private cacheDir: string;
+  private maxSizeMb: number;
+
+  constructor(options: FileHashCacheOptions) {
+    this.cacheDir = options.cacheDir;
+    this.maxSizeMb = options.maxSizeMb;
+  }
+
+  private async getDirSize(): Promise<number> {
+    try {
+      const files = await fs.readdir(this.cacheDir);
+      let total = 0;
+      for (const f of files) {
+        const full = path.join(this.cacheDir, f);
+        const stat = await fs.stat(full);
+        if (stat.isFile()) {
+          total += stat.size;
+        }
+      }
+      return total;
+    } catch {
+      return 0;
+    }
+  }
+
+  private async enforceLimit(): Promise<void> {
+    if (this.maxSizeMb <= 0) {
+      return;
+    }
+
+    await fs.ensureDir(this.cacheDir);
+
+    const maxBytes = this.maxSizeMb * 1024 * 1024;
+    let total = await this.getDirSize();
+    if (total <= maxBytes) return;
+
+    const entries = await fs.readdir(this.cacheDir);
+    const fileStats: { filePath: string; mtimeMs: number; size: number }[] = [];
+
+    for (const name of entries) {
+      const filePath = path.join(this.cacheDir, name);
+      const stat = await fs.stat(filePath);
+      if (stat.isFile()) {
+        fileStats.push({ filePath, mtimeMs: stat.mtimeMs, size: stat.size });
+      }
+    }
+
+    fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+
+    for (const f of fileStats) {
+      if (total <= maxBytes) break;
+      try {
+        await fs.remove(f.filePath);
+        total -= f.size;
+      } catch (e) {
+        logger.warn(`Failed to delete cache file: ${f.filePath}`, e);
+      }
+    }
+  }
+
+  async get(fileHash: string): Promise<FileAnalysis | null> {
+    if (this.maxSizeMb === 0) {
+      return null;
+    }
+    const cachePath = path.join(this.cacheDir, `${fileHash}.json`);
+    try {
+      if (await fs.pathExists(cachePath)) {
+        const data = await fs.readJSON(cachePath);
+        return data as FileAnalysis;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  async set(fileHash: string, result: FileAnalysis): Promise<void> {
+    if (this.maxSizeMb === 0) {
+      return;
+    }
+
+    try {
+      await fs.ensureDir(this.cacheDir);
+      await this.enforceLimit();
+
+      const cachePath = path.join(this.cacheDir, `${fileHash}.json`);
+      await fs.writeJSON(cachePath, result, { spaces: 2 });
+    } catch (error) {
+      // 缓存写入失败不影响主流程
+      logger.warn('Failed to write cache:', error);
+    }
+  }
+
+  async clear(fileHash?: string): Promise<void> {
+    if (fileHash) {
+      const cachePath = path.join(this.cacheDir, `${fileHash}.json`);
+      await fs.remove(cachePath);
+    } else {
+      await fs.emptyDir(this.cacheDir);
+    }
+  }
+
+  static calculateFileHash(content: string): string {
+    return createHash('sha256').update(content).digest('hex');
+  }
+}

package/src/infrastructure/git/git.service.ts

@@ -0,0 +1,120 @@
+import simpleGit, { SimpleGit } from 'simple-git'
+import { IGitService } from '../../domain/interfaces'
+import { AppError, ErrorCode } from '../../common/errors'
+import * as path from 'path'
+
+export class GitService implements IGitService {
+  private gitInstances: Map<string, SimpleGit> = new Map()
+
+  private getGitInstance(projectRoot: string): SimpleGit {
+    if (!this.gitInstances.has(projectRoot)) {
+      this.gitInstances.set(projectRoot, simpleGit(projectRoot))
+    }
+    return this.gitInstances.get(projectRoot)!
+  }
+
+  async isGitProject(projectRoot: string): Promise<boolean> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      await git.revparse(['--is-inside-work-tree'])
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  async getCurrentCommit(projectRoot: string): Promise<string> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const commitHash = await git.revparse(['HEAD'])
+      return commitHash.trim()
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get current commit', (e as Error).message)
+    }
+  }
+
+  async getCurrentBranch(projectRoot: string): Promise<string> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const branch = await git.revparse(['--abbrev-ref', 'HEAD'])
+      return branch.trim()
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get current branch', (e as Error).message)
+    }
+  }
+
+  async getProjectSlug(projectRoot: string): Promise<string> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const remoteUrl = await git.remote(['get-url', 'origin'])
+      const url = (remoteUrl || '').trim()
+      
+      // 处理SSH和HTTPS格式的URL
+      let slug: string
+      if (url.startsWith('git@')) {
+        slug = url.split(':')[1].replace('.git', '')
+      } else if (url.startsWith('http')) {
+        const parts = new URL(url).pathname.split('/')
+        slug = `${parts[1]}/${parts[2].replace('.git', '')}`
+      } else {
+        // 如果没有远程仓库，使用目录名作为slug
+        slug = path.basename(projectRoot)
+      }
+      
+      return slug.toLowerCase().replace(/[^a-z0-9-_/]/g, '-')
+    } catch (e) {
+      // 如果获取远程URL失败，使用目录名作为slug
+      return path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9-_]/g, '-')
+    }
+  }
+
+  async getUncommittedChanges(projectRoot: string): Promise<string[]> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const status = await git.status()
+      return [...status.modified, ...status.created, ...status.deleted, ...status.renamed.map(r => r.to)]
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get uncommitted changes', (e as Error).message)
+    }
+  }
+
+  async diffCommits(projectRoot: string, commit1: string, commit2: string): Promise<string[]> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const diff = await git.diff(['--name-only', commit1, commit2])
+      return diff.trim().split('\n').filter(line => line.length > 0)
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to diff commits', (e as Error).message)
+    }
+  }
+
+  async getFileLastCommit(projectRoot: string, filePath: string): Promise<string | null> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const result = await git.raw(['log', '-n', '1', '--pretty=format:%H', '--', filePath])
+      const hash = result.trim()
+      return hash || null
+    } catch {
+      // 对于未纳入 Git 管理或无提交记录的文件，返回 null
+      return null
+    }
+  }
+
+  async isFileDirty(projectRoot: string, filePath: string): Promise<boolean> {
+    try {
+      const git = this.getGitInstance(projectRoot)
+      const status = await git.status()
+      const normalizedPath = filePath.replace(/\\/g, '/')
+
+      if (status.modified.includes(normalizedPath)) return true
+      if (status.created.includes(normalizedPath)) return true
+      if (status.deleted.includes(normalizedPath)) return true
+      if (status.renamed.some(r => r.to === normalizedPath || r.from === normalizedPath)) return true
+
+      return false
+    } catch {
+      // Git 不可用时视为非 dirty，交由上层逻辑处理
+      return false
+    }
+  }
+}

package/src/infrastructure/git.service.ts

@@ -0,0 +1,121 @@
+import simpleGit, { SimpleGit } from 'simple-git'
+import * as fs from 'fs-extra'
+import { IGitService } from '../domain/interfaces'
+import { AppError, ErrorCode } from '../common/errors'
+
+export class GitService implements IGitService {
+  private git?: SimpleGit
+  private projectRoot: string
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot
+  }
+
+  private getGit(): SimpleGit {
+    if (!this.git) {
+      this.git = simpleGit(this.projectRoot)
+    }
+    return this.git
+  }
+
+  async isGitProject(): Promise<boolean> {
+    try {
+      // 先判断目录是否存在
+      if (!(await fs.pathExists(this.projectRoot))) {
+        return false
+      }
+      return await this.getGit().checkIsRepo()
+    } catch {
+      return false
+    }
+  }
+
+  async getCurrentCommit(): Promise<string> {
+    // 重试3次，避免Windows下git命令偶发失败
+    const maxRetries = 3;
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return await this.getGit().revparse(['HEAD'])
+      } catch (e) {
+        if (i === maxRetries - 1) {
+          throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get current commit', e)
+        }
+        await new Promise(resolve => setTimeout(resolve, 100 * (i + 1)));
+      }
+    }
+    throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get current commit')
+  }
+
+  async getCurrentBranch(): Promise<string> {
+    try {
+      return await this.getGit().revparse(['--abbrev-ref', 'HEAD'])
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get current branch', e)
+    }
+  }
+
+  async getProjectSlug(): Promise<string> {
+    try {
+      // 尝试从remote url获取slug
+      const remoteUrl = (await this.getGit().remote(['get-url', 'origin'])) as string
+      const match = remoteUrl?.match(/[:/]([^/]+\/[^/.]+)(\.git)?$/)
+      if (match) {
+        return match[1]
+      }
+    } catch (e) {
+      // 没有remote的情况，使用目录名作为slug
+      const path = require('path')
+      const crypto = require('crypto')
+      const dirName = path.basename(this.projectRoot)
+      const hash = crypto.createHash('md5').update(this.projectRoot).digest('hex').slice(0, 8)
+      return `${dirName}-${hash}`
+    }
+    // 无法解析remote的情况，同样使用目录名加hash
+    const path = require('path')
+    const crypto = require('crypto')
+    const dirName = path.basename(this.projectRoot)
+    const hash = crypto.createHash('md5').update(this.projectRoot).digest('hex').slice(0, 8)
+    return `${dirName}-${hash}`
+  }
+
+  async getUncommittedChanges(): Promise<string[]> {
+    try {
+      const status = await this.getGit().status()
+      return status.files.map(f => f.path)
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to get uncommitted changes', e)
+    }
+  }
+
+  async diffCommits(commit1: string, commit2: string): Promise<string[]> {
+    try {
+      const diff = await this.getGit().diff([`${commit1}..${commit2}`, '--name-only'])
+      return diff.split('\n').filter(Boolean)
+    } catch (e) {
+      throw new AppError(ErrorCode.GIT_OPERATION_FAILED, 'Failed to diff commits', e)
+    }
+  }
+
+  async getFileLastCommit(projectRoot: string, filePath: string): Promise<string | null> {
+    try {
+      const git = this.getGit()
+      const relPath = filePath
+      const log = await git.raw(['log', '-n', '1', '--pretty=format:%H', '--', relPath])
+      const trimmed = (log || '').trim()
+      return trimmed || null
+    } catch {
+      return null
+    }
+  }
+
+  async isFileDirty(projectRoot: string, filePath: string): Promise<boolean> {
+    try {
+      const git = this.getGit()
+      const status = await git.status()
+      return status.files.some(f => f.path === filePath)
+    } catch {
+      // git 不可用时视为非 dirty，交由上层按非 git 场景处理
+      return false
+    }
+  }
+}

package/src/infrastructure/index.service.ts

@@ -0,0 +1,94 @@
+import * as fs from 'fs-extra'
+import * as path from 'path'
+import { AnalysisIndex, IndexEntry } from '../common/types'
+import { normalizePath } from '../common/utils'
+
+// V2.6 起不再在主流程生成/依赖 analysis-index.json。
+// 为兼容历史代码/测试，此类暂保留，但不再实现 IIndexService 接口。
+export class IndexService {
+  private getIndexFilePath(storageRoot: string): string {
+    return path.join(storageRoot, 'analysis-index.json')
+  }
+
+  async buildIndex(
+    projectRoot: string,
+    storageRoot: string,
+    fileEntries: Array<{ sourcePath: string; resultPath: string }>,
+    dirEntries: Array<{ sourcePath: string; resultPath: string }>
+  ): Promise<void> {
+    const entries: Record<string, IndexEntry> = {}
+
+    for (const entry of fileEntries) {
+      entries[normalizePath(entry.sourcePath)] = {
+        resultPath: normalizePath(entry.resultPath),
+        type: 'file',
+      }
+    }
+
+    for (const entry of dirEntries) {
+      entries[normalizePath(entry.sourcePath)] = {
+        resultPath: normalizePath(entry.resultPath),
+        type: 'directory',
+      }
+    }
+
+    const indexData: AnalysisIndex = {
+      version: '1.0',
+      projectRoot: normalizePath(projectRoot),
+      storageRoot: normalizePath(storageRoot),
+      generatedAt: new Date().toISOString(),
+      entries,
+    }
+
+    const indexPath = this.getIndexFilePath(storageRoot)
+    await fs.ensureDir(path.dirname(indexPath))
+    await fs.writeJson(indexPath, indexData, { spaces: 2 })
+  }
+
+  async updateIndex(
+    storageRoot: string,
+    updatedEntries: Array<{ sourcePath: string; resultPath: string; type: 'file' | 'directory' }>,
+    removedPaths: string[]
+  ): Promise<void> {
+    const existing = (await this.readIndex(storageRoot)) ?? {
+      version: '1.0',
+      projectRoot: '',
+      storageRoot,
+      generatedAt: new Date().toISOString(),
+      entries: {} as Record<string, IndexEntry>,
+    }
+
+    for (const removedPath of removedPaths) {
+      delete existing.entries[normalizePath(removedPath)]
+    }
+
+    for (const entry of updatedEntries) {
+      existing.entries[normalizePath(entry.sourcePath)] = {
+        resultPath: normalizePath(entry.resultPath),
+        type: entry.type,
+      }
+    }
+
+    existing.generatedAt = new Date().toISOString()
+
+    const indexPath = this.getIndexFilePath(storageRoot)
+    await fs.writeJson(indexPath, existing, { spaces: 2 })
+  }
+
+  async readIndex(storageRoot: string): Promise<AnalysisIndex | null> {
+    const indexPath = this.getIndexFilePath(storageRoot)
+    if (await fs.pathExists(indexPath)) {
+      return await fs.readJson(indexPath)
+    }
+    return null
+  }
+
+  async resolve(storageRoot: string, absolutePath: string): Promise<string | null> {
+    const indexData = await this.readIndex(storageRoot)
+    if (!indexData) return null
+
+    const normalized = normalizePath(absolutePath)
+    const entry = indexData.entries[normalized]
+    return entry ? entry.resultPath : null
+  }
+}

package/src/infrastructure/llm/llm.usage.tracker.ts

@@ -0,0 +1,65 @@
+import type { TokenUsageStats } from '../../common/types'
+
+/**
+ * 单次解析周期内的 LLM Token 使用统计器。
+ *
+ * - 对所有调用做累计统计；
+ * - 通过 onSnapshot 回调向上层（如 CLI 渲染器）推送最新快照；
+ * - 不直接向 stdout 打印 Token 行，由 CLI 统一渲染「Tokens: ...」。
+ */
+export class LLMUsageTracker {
+  private stats: TokenUsageStats = {
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalTokens: 0,
+    totalCalls: 0,
+  }
+
+  constructor(
+    private readonly onSnapshot?: (stats: TokenUsageStats) => void,
+  ) {}
+
+  addUsage(usage: { promptTokens?: number; completionTokens?: number; totalTokens?: number }): void {
+    this.stats.totalPromptTokens += usage.promptTokens ?? 0
+    this.stats.totalCompletionTokens += usage.completionTokens ?? 0
+    this.stats.totalTokens += usage.totalTokens ?? 0
+    this.stats.totalCalls += 1
+
+    const snapshot = this.getStats()
+
+    if (this.onSnapshot) {
+      this.onSnapshot(snapshot)
+    }
+  }
+
+  /**
+   * 将外部汇总（例如 worker 线程返回的本任务 usage delta）累加到总量中。
+   * 注意：这里的 totalCalls 表示调用次数增量，而不是“任务数”。
+   */
+  addTotals(delta: Partial<TokenUsageStats>): void {
+    this.stats.totalPromptTokens += delta.totalPromptTokens ?? 0
+    this.stats.totalCompletionTokens += delta.totalCompletionTokens ?? 0
+    this.stats.totalTokens += delta.totalTokens ?? 0
+    this.stats.totalCalls += delta.totalCalls ?? 0
+
+    const snapshot = this.getStats()
+
+    if (this.onSnapshot) {
+      this.onSnapshot(snapshot)
+    }
+  }
+
+  getStats(): TokenUsageStats {
+    return { ...this.stats }
+  }
+
+  reset(): void {
+    this.stats = {
+      totalPromptTokens: 0,
+      totalCompletionTokens: 0,
+      totalTokens: 0,
+      totalCalls: 0,
+    }
+  }
+}
+