ai-code-detector 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,234 @@
+# @cc-tools/ai-code-detector
+
+基于困惑度(Perplexity)检测 AI 生成代码的 npm 包，支持多种编程语言，提供 CLI 和 API 两种使用方式。
+
+## 安装
+
+```bash
+npm install @cc-tools/ai-code-detector
+# 或
+yarn add @cc-tools/ai-code-detector
+# 或
+pnpm add @cc-tools/ai-code-detector
+```
+
+## 快速开始
+
+### CLI 使用
+
+```bash
+# 全局安装后直接使用
+ai-code-detector -i ./src/index.ts
+
+# 或使用 npx
+npx @cc-tools/ai-code-detector -i ./src/index.ts
+```
+
+#### CLI 参数
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `-i, --input <path>` | 输入文件或目录路径 | 必填 |
+| `-o, --output <path>` | 输出报告文件路径 | 可选 |
+| `-t, --threshold <num>` | 困惑度阈值 | 15.0 |
+| `-m, --model <name>` | 使用的模型名称 | Xenova/codebert-base |
+| `-f, --format <type>` | 输出格式 (text/json) | text |
+| `-h, --help` | 显示帮助信息 | - |
+
+#### CLI 示例
+
+```bash
+# 检测单个文件
+ai-code-detector -i ./src/index.ts
+
+# 检测目录下所有代码文件
+ai-code-detector -i ./src/
+
+# 输出 JSON 格式
+ai-code-detector -i ./code.js -f json
+
+# 自定义阈值并保存报告
+ai-code-detector -i ./project/ -t 20 -o report.txt
+```
+
+### API 使用
+
+```typescript
+import { detectAICode, analyzeCodeSegments, calculatePerplexity } from '@cc-tools/ai-code-detector';
+
+// 完整检测报告
+const report = await detectAICode(codeString, {
+  threshold: 15.0,      // 困惑度阈值
+  chunkSize: 512,       // 代码块大小
+  overlapSize: 50,      // 重叠大小
+});
+
+console.log(report.summary);
+console.log(`是否为 AI 生成: ${report.isAIGenerated}`);
+console.log(`整体评分: ${report.overallScore}/100`);
+
+// 仅分析代码段
+const segments = await analyzeCodeSegments(codeString);
+segments.forEach(seg => {
+  console.log(`行 ${seg.segment.startLine}-${seg.segment.endLine}: 困惑度=${seg.perplexity.toFixed(2)}`);
+});
+
+// 仅计算困惑度
+const perplexity = await calculatePerplexity(codeString);
+console.log(`困惑度: ${perplexity}`);
+```
+
+## 检测原理
+
+### 困惑度 (Perplexity)
+
+困惑度是衡量语言模型对文本"惊讶程度"的指标：
+
+- **低困惑度** (< 阈值): 代码更加"可预测"，模式规整，可能是 AI 生成
+- **高困惑度** (> 阈值): 代码更加"多样/复杂"，更可能是人类编写
+
+### 检测流程
+
+1. **代码分段**: 识别代码逻辑块（函数、类、条件语句等）
+2. **困惑度计算**: 使用 CodeBERT 模型或启发式算法计算每段代码的困惑度
+3. **阈值判断**: 与设定阈值比较，判断是否为 AI 生成
+4. **报告生成**: 汇总结果，生成详细检测报告
+
+### 支持的语言
+
+- JavaScript / TypeScript
+- Python
+- Java
+- Go
+- Rust
+- C / C++
+- C#
+- Ruby
+- PHP
+- Swift
+- Kotlin
+- Scala
+- SQL
+
+## API 文档
+
+### `detectAICode(code, options?)`
+
+执行完整的 AI 代码检测，返回检测报告。
+
+```typescript
+interface DetectionOptions {
+  model?: string;       // 模型名称，默认 'Xenova/codebert-base'
+  threshold?: number;   // 困惑度阈值，默认 15.0
+  chunkSize?: number;   // 代码块大小，默认 512
+  overlapSize?: number; // 重叠大小，默认 50
+  language?: string;    // 指定语言（可选）
+}
+
+interface DetectionReport {
+  overallScore: number;         // 整体评分 (0-100)
+  isAIGenerated: boolean;       // 是否为 AI 生成
+  totalSegments: number;        // 总代码段数
+  aiGeneratedSegments: number;  // AI 生成段数
+  humanWrittenSegments: number; // 人类编写段数
+  segments: SegmentResult[];    // 分段详细结果
+  summary: string;              // 摘要
+  recommendations: string[];    // 建议
+  metadata: {                   // 元数据
+    model: string;
+    threshold: number;
+    timestamp: string;
+    language: string;
+  };
+}
+```
+
+### `analyzeCodeSegments(code, options?)`
+
+分析代码段，返回每段的检测结果。
+
+### `calculatePerplexity(code, options?)`
+
+计算代码的困惑度值。
+
+### `ReportGenerator`
+
+报告生成器类，支持格式化输出。
+
+```typescript
+import { ReportGenerator } from '@cc-tools/ai-code-detector';
+
+const generator = new ReportGenerator(options);
+await generator.initialize();
+
+const report = await generator.generateReport(code);
+console.log(generator.formatReportAsText(report));
+console.log(generator.formatReportAsJSON(report));
+```
+
+## 示例输出
+
+```
+============================================================
+              AI 代码检测报告
+============================================================
+
+检测时间: 2024-01-15T10:30:00.000Z
+使用模型: Xenova/codebert-base
+检测语言: typescript
+阈值设置: 15
+
+------------------------------------------------------------
+                      检测结果
+------------------------------------------------------------
+
+整体评分: 35/100
+判定结果: ⚠️ 可能是AI生成
+总代码段: 5
+AI生成段: 4
+人类编写段: 1
+
+------------------------------------------------------------
+                       摘要
+------------------------------------------------------------
+
+该代码显示出明显的AI生成特征。约80%的代码段被判定为AI生成，
+平均困惑度为8.52，低于设定的阈值。
+
+------------------------------------------------------------
+                      建议
+------------------------------------------------------------
+
+1. 所有代码段都显示出AI生成的特征，建议检查代码的原创性
+2. AI生成置信度较高，建议添加更多人工注释和定制化逻辑
+```
+
+## 注意事项
+
+1. **模型加载**: 首次使用时会自动下载模型，可能需要一些时间
+2. **阈值调整**: 默认阈值 15.0 适用于大多数场景，可根据实际情况调整
+3. **检测结果**: 仅供参考，不能作为判断代码来源的唯一依据
+4. **性能**: 大型代码文件可能需要较长时间处理
+
+## 开发
+
+```bash
+# 克隆仓库
+git clone https://github.com/cc-cc/cc-tools.git
+
+# 进入包目录
+cd packages/ai-code-detector
+
+# 安装依赖
+npm install
+
+# 构建
+npm run build
+
+# 测试
+node dist/cli.js -i ./src/index.ts
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { detectAICode, DEFAULT_OPTIONS } from './index.js';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '-i':
+            case '--input':
+                options.input = args[++i];
+                break;
+            case '-o':
+            case '--output':
+                options.output = args[++i];
+                break;
+            case '-t':
+            case '--threshold':
+                options.threshold = parseFloat(args[++i]);
+                break;
+            case '-m':
+            case '--model':
+                options.model = args[++i];
+                break;
+            case '-f':
+            case '--format':
+                options.format = args[++i];
+                break;
+            case '-h':
+            case '--help':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`
+AI Code Detector - 基于困惑度的AI代码检测工具
+
+用法: ai-code-detector [选项]
+
+选项:
+  -i, --input <path>      输入文件或目录路径
+  -o, --output <path>    输出报告文件路径 (可选)
+  -t, --threshold <num>  困惑度阈值 (默认: 15.0)
+  -m, --model <name>     使用的模型名称 (默认: Xenova/codebert-base)
+  -f, --format <type>    输出格式: text 或 json (默认: text)
+  -h, --help             显示帮助信息
+
+示例:
+  ai-code-detector --input ./src/index.ts
+  ai-code-detector -i ./code.js -t 20 -f json
+  ai-code-detector -i ./project/ -o report.txt
+`);
+}
+function readCodeFromFile(filePath) {
+    try {
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        console.error(`Error reading file: ${filePath}`);
+        process.exit(1);
+    }
+}
+function isValidCodeFile(filePath) {
+    const validExtensions = [
+        '.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go',
+        '.rs', '.cpp', '.c', '.h', '.hpp', '.cs', '.rb',
+        '.php', '.swift', '.kt', '.scala', '.sql'
+    ];
+    return validExtensions.includes(extname(filePath).toLowerCase());
+}
+async function main() {
+    const options = parseArgs();
+    if (!options.input) {
+        console.error('Error: Please specify input file or directory');
+        printHelp();
+        process.exit(1);
+    }
+    const stats = statSync(options.input);
+    let code = '';
+    let fileName = options.input;
+    if (stats.isDirectory()) {
+        const files = readdirSync(options.input);
+        const codeFiles = files
+            .map(f => join(options.input, f))
+            .filter(f => statSync(f).isFile() && isValidCodeFile(f));
+        if (codeFiles.length === 0) {
+            console.error('No valid code files found in directory');
+            process.exit(1);
+        }
+        code = codeFiles.map(f => readCodeFromFile(f)).join('\n\n');
+        fileName = `${options.input} (${codeFiles.length} files)`;
+    }
+    else {
+        code = readCodeFromFile(options.input);
+    }
+    console.log(`\n正在分析代码: ${fileName}`);
+    console.log('加载模型中...\n');
+    const detectOptions = {
+        ...DEFAULT_OPTIONS,
+        threshold: options.threshold,
+        model: options.model,
+    };
+    try {
+        const report = await detectAICode(code, detectOptions);
+        const format = options.format || 'text';
+        let output;
+        const { ReportGenerator } = await import('./report.js');
+        const generator = new ReportGenerator(detectOptions);
+        if (format === 'json') {
+            output = JSON.stringify(report, null, 2);
+        }
+        else {
+            output = generator.formatReportAsText(report);
+        }
+        if (options.output) {
+            const { writeFileSync } = await import('fs');
+            writeFileSync(options.output, output, 'utf-8');
+            console.log(`\n报告已保存到: ${options.output}`);
+        }
+        else {
+            console.log(output);
+        }
+        process.exit(report.isAIGenerated ? 0 : 0);
+    }
+    catch (error) {
+        console.error('Error during detection:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/detector.d.ts

@@ -0,0 +1,23 @@
+import type { CodeSegment, DetectionOptions, SegmentResult } from './types.js';
+export declare class CodeSegmenter {
+    private chunkSize;
+    private overlapSize;
+    constructor(options?: DetectionOptions);
+    segmentCode(code: string): CodeSegment[];
+    private identifyLogicalBlocks;
+    private isBlockStart;
+    private splitLargeBlock;
+}
+export declare class AICodeDetector {
+    private perplexityCalculator;
+    private segmenter;
+    private threshold;
+    private options;
+    constructor(options?: DetectionOptions);
+    initialize(): Promise<void>;
+    detect(code: string): Promise<SegmentResult[]>;
+    private calculateConfidence;
+    getThreshold(): number;
+    setThreshold(threshold: number): void;
+}
+//# sourceMappingURL=detector.d.ts.map

package/dist/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAI/E,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,gBAAqB;IAK1C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE;IAwBxC,OAAO,CAAC,qBAAqB;IAyC7B,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,eAAe;CAgCxB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAmB;gBAEtB,OAAO,GAAE,gBAAqB;IAOpC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAoBpD,OAAO,CAAC,mBAAmB;IAO3B,YAAY,IAAI,MAAM;IAItB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAGtC"}

package/dist/detector.js

@@ -0,0 +1,132 @@
+import { PerplexityCalculator } from './perplexity.js';
+import { DEFAULT_CHUNK_SIZE, DEFAULT_OVERLAP_SIZE, DEFAULT_THRESHOLD } from './types.js';
+export class CodeSegmenter {
+    chunkSize;
+    overlapSize;
+    constructor(options = {}) {
+        this.chunkSize = options.chunkSize || DEFAULT_CHUNK_SIZE;
+        this.overlapSize = options.overlapSize || DEFAULT_OVERLAP_SIZE;
+    }
+    segmentCode(code) {
+        const lines = code.split('\n');
+        const segments = [];
+        const logicalBlocks = this.identifyLogicalBlocks(lines);
+        for (const block of logicalBlocks) {
+            const blockContent = lines.slice(block.start, block.end + 1).join('\n');
+            if (blockContent.length > this.chunkSize) {
+                const subSegments = this.splitLargeBlock(lines, block.start, block.end);
+                segments.push(...subSegments);
+            }
+            else {
+                segments.push({
+                    content: blockContent,
+                    startLine: block.start + 1,
+                    endLine: block.end + 1,
+                });
+            }
+        }
+        return segments;
+    }
+    identifyLogicalBlocks(lines) {
+        const blocks = [];
+        let currentBlock = null;
+        let depth = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const openBraces = (line.match(/{/g) || []).length;
+            const closeBraces = (line.match(/}/g) || []).length;
+            if (currentBlock === null && (openBraces > 0 || this.isBlockStart(line))) {
+                currentBlock = { start: i, depth };
+            }
+            depth += openBraces - closeBraces;
+            if (currentBlock !== null && depth === currentBlock.depth && closeBraces > 0) {
+                blocks.push({ start: currentBlock.start, end: i });
+                currentBlock = null;
+            }
+        }
+        if (blocks.length === 0) {
+            return [{ start: 0, end: lines.length - 1 }];
+        }
+        let lastEnd = -1;
+        for (let i = 0; i < blocks.length; i++) {
+            if (blocks[i].start > lastEnd + 1) {
+                blocks.splice(i, 0, { start: lastEnd + 1, end: blocks[i].start - 1 });
+            }
+            lastEnd = blocks[i].end;
+        }
+        if (lastEnd < lines.length - 1) {
+            blocks.push({ start: lastEnd + 1, end: lines.length - 1 });
+        }
+        return blocks;
+    }
+    isBlockStart(line) {
+        const blockKeywords = ['function', 'class', 'interface', 'if', 'for', 'while', 'switch', 'try'];
+        const trimmed = line.trim();
+        return blockKeywords.some(kw => trimmed.startsWith(kw));
+    }
+    splitLargeBlock(lines, startLine, endLine) {
+        const segments = [];
+        let currentStart = startLine;
+        while (currentStart <= endLine) {
+            let currentEnd = currentStart;
+            let currentLength = 0;
+            while (currentEnd <= endLine && currentLength < this.chunkSize) {
+                currentLength += lines[currentEnd].length + 1;
+                currentEnd++;
+            }
+            if (currentEnd > endLine) {
+                currentEnd = endLine + 1;
+            }
+            segments.push({
+                content: lines.slice(currentStart, currentEnd).join('\n'),
+                startLine: currentStart + 1,
+                endLine: currentEnd,
+            });
+            currentStart = Math.max(currentEnd - this.overlapSize, currentEnd);
+        }
+        return segments;
+    }
+}
+export class AICodeDetector {
+    perplexityCalculator;
+    segmenter;
+    threshold;
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        this.threshold = options.threshold || DEFAULT_THRESHOLD;
+        this.perplexityCalculator = new PerplexityCalculator(options);
+        this.segmenter = new CodeSegmenter(options);
+    }
+    async initialize() {
+        await this.perplexityCalculator.initialize();
+    }
+    async detect(code) {
+        const segments = this.segmenter.segmentCode(code);
+        const results = [];
+        for (const segment of segments) {
+            const perplexity = await this.perplexityCalculator.calculatePerplexity(segment.content);
+            const isAIGenerated = perplexity < this.threshold;
+            const confidence = this.calculateConfidence(perplexity);
+            results.push({
+                segment,
+                perplexity,
+                isAIGenerated,
+                confidence,
+            });
+        }
+        return results;
+    }
+    calculateConfidence(perplexity) {
+        const distance = Math.abs(perplexity - this.threshold);
+        const maxDistance = 20;
+        const confidence = Math.min(distance / maxDistance, 1) * 100;
+        return Math.round(confidence);
+    }
+    getThreshold() {
+        return this.threshold;
+    }
+    setThreshold(threshold) {
+        this.threshold = threshold;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ReportGenerator } from './report.js';
+import { AICodeDetector } from './detector.js';
+import { PerplexityCalculator } from './perplexity.js';
+import type { DetectionOptions, DetectionReport, SegmentResult } from './types.js';
+export { AICodeDetector, PerplexityCalculator, ReportGenerator, };
+export type { DetectionOptions, DetectionReport, SegmentResult, CodeSegment, } from './types.js';
+export declare function detectAICode(code: string, options?: DetectionOptions): Promise<DetectionReport>;
+export declare function analyzeCodeSegments(code: string, options?: DetectionOptions): Promise<SegmentResult[]>;
+export declare function calculatePerplexity(code: string, options?: DetectionOptions): Promise<number>;
+export declare const DEFAULT_OPTIONS: DetectionOptions;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEnF,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,eAAe,GAChB,CAAC;AAEF,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAI1B;AAED,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CAI1B;AAED,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,eAAO,MAAM,eAAe,EAAE,gBAK7B,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+import { ReportGenerator } from './report.js';
+import { AICodeDetector } from './detector.js';
+import { PerplexityCalculator } from './perplexity.js';
+export { AICodeDetector, PerplexityCalculator, ReportGenerator, };
+export async function detectAICode(code, options = {}) {
+    const generator = new ReportGenerator(options);
+    await generator.initialize();
+    return generator.generateReport(code, options);
+}
+export async function analyzeCodeSegments(code, options = {}) {
+    const detector = new AICodeDetector(options);
+    await detector.initialize();
+    return detector.detect(code);
+}
+export async function calculatePerplexity(code, options = {}) {
+    const calculator = new PerplexityCalculator(options);
+    await calculator.initialize();
+    return calculator.calculatePerplexity(code);
+}
+export const DEFAULT_OPTIONS = {
+    model: 'Xenova/codebert-base',
+    threshold: 15.0,
+    chunkSize: 512,
+    overlapSize: 50,
+};

package/dist/perplexity.d.ts

@@ -0,0 +1,22 @@
+import type { DetectionOptions, ModelConfig } from './types.js';
+export declare class PerplexityCalculator {
+    private model;
+    private tokenizer;
+    private model_instance;
+    private initialized;
+    constructor(options?: DetectionOptions);
+    initialize(): Promise<void>;
+    calculatePerplexity(text: string): Promise<number>;
+    private tokenizeCode;
+    private computePerplexityWithMasking;
+    private tokenSimilarity;
+    private heuristicPerplexity;
+    private countRepeatedPatterns;
+    private countCommonKeywords;
+    private calculateStructureRegularity;
+    private calculateNamingConsistency;
+    private calculateCommentRatio;
+    private calculateLineLengthVariance;
+    getModelInfo(): ModelConfig;
+}
+//# sourceMappingURL=perplexity.d.ts.map

package/dist/perplexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perplexity.d.ts","sourceRoot":"","sources":["../src/perplexity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAKhE,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,WAAW,CAAkB;gBAEzB,OAAO,GAAE,gBAAqB;IAIpC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBxD,OAAO,CAAC,YAAY;YASN,4BAA4B;IA8C1C,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,mBAAmB;IA0B3B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,4BAA4B;IAcpC,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,2BAA2B;IAUnC,YAAY,IAAI,WAAW;CAO5B"}

package/dist/perplexity.js

@@ -0,0 +1,180 @@
+import { pipeline, env } from '@xenova/transformers';
+import { DEFAULT_MODEL, DEFAULT_THRESHOLD } from './types.js';
+env.allowLocalModels = false;
+export class PerplexityCalculator {
+    model;
+    tokenizer = null;
+    model_instance = null;
+    initialized = false;
+    constructor(options = {}) {
+        this.model = options.model || DEFAULT_MODEL;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            console.log(`Loading model: ${this.model}...`);
+            this.model_instance = await pipeline('fill-mask', this.model, {
+                quantized: true,
+            });
+            this.initialized = true;
+            console.log('Model loaded successfully');
+        }
+        catch (error) {
+            console.warn('Failed to load primary model, using fallback approach');
+            this.initialized = true;
+        }
+    }
+    async calculatePerplexity(text) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        if (!text || text.trim().length === 0) {
+            return 0;
+        }
+        const tokens = this.tokenizeCode(text);
+        if (tokens.length < 2) {
+            return 0;
+        }
+        try {
+            return await this.computePerplexityWithMasking(text, tokens);
+        }
+        catch (error) {
+            return this.heuristicPerplexity(text, tokens);
+        }
+    }
+    tokenizeCode(code) {
+        return code
+            .replace(/[{}()\[\];,]/g, ' $& ')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .split(' ')
+            .filter(t => t.length > 0);
+    }
+    async computePerplexityWithMasking(code, tokens) {
+        const sampleSize = Math.min(10, Math.floor(tokens.length / 3));
+        const sampleIndices = [];
+        for (let i = 0; i < sampleSize; i++) {
+            const idx = Math.floor(Math.random() * (tokens.length - 2)) + 1;
+            if (!sampleIndices.includes(idx)) {
+                sampleIndices.push(idx);
+            }
+        }
+        let totalLogProb = 0;
+        let validSamples = 0;
+        for (const idx of sampleIndices) {
+            const maskedTokens = [...tokens];
+            const originalToken = maskedTokens[idx];
+            maskedTokens[idx] = '[MASK]';
+            const maskedText = maskedTokens.join(' ');
+            try {
+                if (this.model_instance) {
+                    const results = await this.model_instance(maskedText);
+                    const topResult = Array.isArray(results) ? results[0] : results;
+                    const predictedToken = topResult?.token_str || '';
+                    const similarity = this.tokenSimilarity(originalToken, predictedToken);
+                    totalLogProb += Math.log(Math.max(similarity, 0.01));
+                    validSamples++;
+                }
+            }
+            catch {
+                validSamples++;
+            }
+        }
+        if (validSamples === 0) {
+            return this.heuristicPerplexity(code, tokens);
+        }
+        const avgLogProb = totalLogProb / validSamples;
+        const perplexity = Math.exp(-avgLogProb);
+        return Math.max(1, Math.min(100, perplexity));
+    }
+    tokenSimilarity(token1, token2) {
+        if (token1 === token2)
+            return 1.0;
+        if (token1.toLowerCase() === token2.toLowerCase())
+            return 0.9;
+        const commonChars = [...token1.toLowerCase()].filter(c => token2.toLowerCase().includes(c)).length;
+        return commonChars / Math.max(token1.length, token2.length, 1);
+    }
+    heuristicPerplexity(code, tokens) {
+        let score = 0;
+        const patterns = {
+            repeatedTokens: this.countRepeatedPatterns(tokens),
+            commonKeywords: this.countCommonKeywords(tokens),
+            structureRegularity: this.calculateStructureRegularity(code),
+            namingConsistency: this.calculateNamingConsistency(tokens),
+            commentRatio: this.calculateCommentRatio(code),
+            lineLengthVariance: this.calculateLineLengthVariance(code),
+        };
+        score += patterns.repeatedTokens * 2;
+        score += patterns.commonKeywords * 1.5;
+        score += patterns.structureRegularity * 3;
+        score += patterns.namingConsistency * 2;
+        score -= patterns.commentRatio * 5;
+        score += patterns.lineLengthVariance * 0.5;
+        const uniqueTokens = new Set(tokens).size;
+        const uniquenessRatio = uniqueTokens / tokens.length;
+        score += (1 - uniquenessRatio) * 10;
+        return Math.max(1, Math.min(100, 15 + score));
+    }
+    countRepeatedPatterns(tokens) {
+        const patterns = {};
+        for (let i = 0; i < tokens.length - 1; i++) {
+            const pattern = `${tokens[i]} ${tokens[i + 1]}`;
+            patterns[pattern] = (patterns[pattern] || 0) + 1;
+        }
+        return Object.values(patterns).filter(c => c > 2).length;
+    }
+    countCommonKeywords(tokens) {
+        const keywords = new Set([
+            'function', 'const', 'let', 'var', 'if', 'else', 'for', 'while',
+            'return', 'import', 'export', 'class', 'interface', 'type',
+            'async', 'await', 'try', 'catch', 'throw', 'new', 'this'
+        ]);
+        return tokens.filter(t => keywords.has(t)).length;
+    }
+    calculateStructureRegularity(code) {
+        const lines = code.split('\n');
+        const indentations = lines
+            .filter(l => l.trim().length > 0)
+            .map(l => l.match(/^\s*/)?.[0].length || 0);
+        if (indentations.length < 2)
+            return 0;
+        const avgIndent = indentations.reduce((a, b) => a + b, 0) / indentations.length;
+        const variance = indentations.reduce((sum, i) => sum + Math.pow(i - avgIndent, 2), 0) / indentations.length;
+        return Math.min(10, variance / 10);
+    }
+    calculateNamingConsistency(tokens) {
+        const identifiers = tokens.filter(t => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(t));
+        if (identifiers.length < 3)
+            return 0;
+        const camelCase = identifiers.filter(t => /[a-z][A-Z]/.test(t)).length;
+        const snakeCase = identifiers.filter(t => t.includes('_')).length;
+        const dominant = Math.max(camelCase, snakeCase);
+        const consistency = dominant / identifiers.length;
+        return consistency * 5;
+    }
+    calculateCommentRatio(code) {
+        const lines = code.split('\n');
+        const commentLines = lines.filter(l => l.trim().startsWith('//') ||
+            l.trim().startsWith('#') ||
+            l.trim().startsWith('/*') ||
+            l.trim().startsWith('*')).length;
+        return commentLines / lines.length;
+    }
+    calculateLineLengthVariance(code) {
+        const lines = code.split('\n').map(l => l.length);
+        if (lines.length < 2)
+            return 0;
+        const avg = lines.reduce((a, b) => a + b, 0) / lines.length;
+        const variance = lines.reduce((sum, l) => sum + Math.pow(l - avg, 2), 0) / lines.length;
+        return Math.sqrt(variance);
+    }
+    getModelInfo() {
+        return {
+            name: this.model,
+            maxTokens: 512,
+            defaultThreshold: DEFAULT_THRESHOLD,
+        };
+    }
+}

package/dist/report.d.ts

@@ -0,0 +1,13 @@
+import type { DetectionReport, DetectionOptions } from './types.js';
+export declare class ReportGenerator {
+    private detector;
+    constructor(options?: DetectionOptions);
+    initialize(): Promise<void>;
+    generateReport(code: string, options?: DetectionOptions): Promise<DetectionReport>;
+    private generateSummary;
+    private generateRecommendations;
+    private detectLanguage;
+    formatReportAsText(report: DetectionReport): string;
+    formatReportAsJSON(report: DetectionReport): string;
+}
+//# sourceMappingURL=report.d.ts.map

package/dist/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnF,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAiB;gBAErB,OAAO,GAAE,gBAAqB;IAIpC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BxF,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,uBAAuB;IA2B/B,OAAO,CAAC,cAAc;IAoBtB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;IAsDnD,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;CAGpD"}

package/dist/report.js

@@ -0,0 +1,134 @@
+import { AICodeDetector } from './detector.js';
+export class ReportGenerator {
+    detector;
+    constructor(options = {}) {
+        this.detector = new AICodeDetector(options);
+    }
+    async initialize() {
+        await this.detector.initialize();
+    }
+    async generateReport(code, options) {
+        const threshold = options?.threshold || this.detector.getThreshold();
+        const results = await this.detector.detect(code);
+        const aiSegments = results.filter(r => r.isAIGenerated);
+        const humanSegments = results.filter(r => !r.isAIGenerated);
+        const avgPerplexity = results.reduce((sum, r) => sum + r.perplexity, 0) / results.length;
+        const aiRatio = results.length > 0 ? aiSegments.length / results.length : 0;
+        const isAIGenerated = aiRatio > 0.5;
+        const overallScore = Math.round((1 - avgPerplexity / 100) * 100);
+        return {
+            overallScore: Math.max(0, Math.min(100, overallScore)),
+            isAIGenerated,
+            totalSegments: results.length,
+            aiGeneratedSegments: aiSegments.length,
+            humanWrittenSegments: humanSegments.length,
+            segments: results,
+            summary: this.generateSummary(isAIGenerated, aiRatio, avgPerplexity),
+            recommendations: this.generateRecommendations(results, threshold),
+            metadata: {
+                model: 'Xenova/codebert-base',
+                threshold,
+                timestamp: new Date().toISOString(),
+                language: this.detectLanguage(code),
+            },
+        };
+    }
+    generateSummary(isAIGenerated, aiRatio, avgPerplexity) {
+        if (isAIGenerated) {
+            return `该代码显示出明显的AI生成特征。约${Math.round(aiRatio * 100)}%的代码段被判定为AI生成，平均困惑度为${avgPerplexity.toFixed(2)}，低于设定的阈值。`;
+        }
+        else {
+            return `该代码更可能由人类编写。只有约${Math.round(aiRatio * 100)}%的代码段显示出AI生成的特征，平均困惑度为${avgPerplexity.toFixed(2)}。`;
+        }
+    }
+    generateRecommendations(results, threshold) {
+        const recommendations = [];
+        const aiSegments = results.filter(r => r.isAIGenerated);
+        if (aiSegments.length === results.length) {
+            recommendations.push('所有代码段都显示出AI生成的特征，建议检查代码的原创性');
+        }
+        if (aiSegments.length > 0) {
+            const avgConfidence = aiSegments.reduce((sum, r) => sum + r.confidence, 0) / aiSegments.length;
+            if (avgConfidence > 80) {
+                recommendations.push('AI生成置信度较高，建议添加更多人工注释和定制化逻辑');
+            }
+        }
+        const lowConfidenceResults = results.filter(r => r.confidence < 30);
+        if (lowConfidenceResults.length > 0) {
+            recommendations.push('部分代码段置信度较低，可能是混合代码或边界情况');
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('代码检测结果正常，未发现明显异常');
+        }
+        return recommendations;
+    }
+    detectLanguage(code) {
+        const patterns = {
+            javascript: [/\bconst\b/, /\blet\b/, /\bfunction\b/, /\b=>\b/, /\bimport\b.*\bfrom\b/],
+            typescript: [/\binterface\b/, /\btype\b.*=/, /:\s*(string|number|boolean|any)\b/],
+            python: [/\bdef\b/, /\bimport\b.*\n/, /\bclass\b.*:/, /\bself\b/],
+            java: [/\bpublic\b.*\bclass\b/, /\bprivate\b/, /\bSystem\.out\.println\b/],
+            go: [/\bfunc\b/, /\bpackage\b/, /\bimport\b.*\(/],
+            rust: [/\bfn\b/, /\blet\s+mut\b/, /\bimpl\b/, /\buse\b.*::/],
+        };
+        for (const [lang, regexes] of Object.entries(patterns)) {
+            const matchCount = regexes.filter(r => r.test(code)).length;
+            if (matchCount >= 2) {
+                return lang;
+            }
+        }
+        return 'unknown';
+    }
+    formatReportAsText(report) {
+        const lines = [];
+        lines.push('='.repeat(60));
+        lines.push('              AI 代码检测报告');
+        lines.push('='.repeat(60));
+        lines.push('');
+        lines.push(`检测时间: ${report.metadata.timestamp}`);
+        lines.push(`使用模型: ${report.metadata.model}`);
+        lines.push(`检测语言: ${report.metadata.language}`);
+        lines.push(`阈值设置: ${report.metadata.threshold}`);
+        lines.push('');
+        lines.push('-'.repeat(60));
+        lines.push('                      检测结果');
+        lines.push('-'.repeat(60));
+        lines.push('');
+        lines.push(`整体评分: ${report.overallScore}/100`);
+        lines.push(`判定结果: ${report.isAIGenerated ? '⚠️ 可能是AI生成' : '✅ 可能是人类编写'}`);
+        lines.push(`总代码段: ${report.totalSegments}`);
+        lines.push(`AI生成段: ${report.aiGeneratedSegments}`);
+        lines.push(`人类编写段: ${report.humanWrittenSegments}`);
+        lines.push('');
+        lines.push('-'.repeat(60));
+        lines.push('                       摘要');
+        lines.push('-'.repeat(60));
+        lines.push('');
+        lines.push(report.summary);
+        lines.push('');
+        lines.push('-'.repeat(60));
+        lines.push('                      建议');
+        lines.push('-'.repeat(60));
+        lines.push('');
+        report.recommendations.forEach((rec, idx) => {
+            lines.push(`${idx + 1}. ${rec}`);
+        });
+        lines.push('');
+        lines.push('-'.repeat(60));
+        lines.push('                    详细分段结果');
+        lines.push('-'.repeat(60));
+        lines.push('');
+        report.segments.forEach((seg, idx) => {
+            lines.push(`[${idx + 1}] 行 ${seg.segment.startLine}-${seg.segment.endLine}`);
+            lines.push(`    困惑度: ${seg.perplexity.toFixed(2)}`);
+            lines.push(`    结果: ${seg.isAIGenerated ? 'AI生成' : '人类编写'}`);
+            lines.push(`    置信度: ${seg.confidence}%`);
+            lines.push('');
+        });
+        lines.push('='.repeat(60));
+        return lines.join('\n');
+    }
+    formatReportAsJSON(report) {
+        return JSON.stringify(report, null, 2);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+export interface DetectionOptions {
+    model?: string;
+    threshold?: number;
+    chunkSize?: number;
+    overlapSize?: number;
+    language?: string;
+}
+export interface CodeSegment {
+    content: string;
+    startLine: number;
+    endLine: number;
+}
+export interface SegmentResult {
+    segment: CodeSegment;
+    perplexity: number;
+    isAIGenerated: boolean;
+    confidence: number;
+}
+export interface DetectionReport {
+    overallScore: number;
+    isAIGenerated: boolean;
+    totalSegments: number;
+    aiGeneratedSegments: number;
+    humanWrittenSegments: number;
+    segments: SegmentResult[];
+    summary: string;
+    recommendations: string[];
+    metadata: {
+        model: string;
+        threshold: number;
+        timestamp: string;
+        language: string;
+    };
+}
+export interface ModelConfig {
+    name: string;
+    maxTokens: number;
+    defaultThreshold: number;
+}
+export declare const DEFAULT_MODEL = "Xenova/codebert-base";
+export declare const DEFAULT_THRESHOLD = 15;
+export declare const DEFAULT_CHUNK_SIZE = 512;
+export declare const DEFAULT_OVERLAP_SIZE = 50;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,aAAa,yBAAyB,CAAC;AACpD,eAAO,MAAM,iBAAiB,KAAO,CAAC;AACtC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,oBAAoB,KAAK,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+export const DEFAULT_MODEL = 'Xenova/codebert-base';
+export const DEFAULT_THRESHOLD = 15.0;
+export const DEFAULT_CHUNK_SIZE = 512;
+export const DEFAULT_OVERLAP_SIZE = 50;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "ai-code-detector",
+  "displayName": "AI Code Detector",
+  "description": "基于困惑度(Perplexity)检测AI生成代码的npm包，支持多种编程语言，提供CLI和API两种使用方式",
+  "version": "0.0.1",
+  "private": false,
+  "license": "MIT",
+  "author": {
+    "name": "CC",
+    "email": "463752412@qq.com"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "ai-code-detector": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ccOfHome/ai-code-detector.git"
+  },
+  "homepage": "https://github.com/ccOfHome/ai-code-detector#readme",
+  "bugs": {
+    "url": "https://github.com/ccOfHome/ai-code-detector/issues"
+  },
+  "keywords": [
+    "ai",
+    "code",
+    "detection",
+    "perplexity",
+    "llm",
+    "ai-generated",
+    "code-analysis",
+    "chatgpt",
+    "copilot",
+    "transformers"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@xenova/transformers": "^2.17.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.9.2"
+  }
+}