ai-yuca 1.0.0

package/src/uploadWithConfig.ts

@@ -0,0 +1,122 @@
+/**
+ * 基于配置文件的GCP上传功能模块
+ */
+import { Storage } from '@google-cloud/storage';
+import * as path from 'path';
+import { StorageClientOptions, UploadFilesResult } from './types/upload';
+import { uploadFiles } from './upload';
+import { loadConfig, getBucketName, getUploadDestination, getUploadSourcePath, VSConfig } from './config';
+
+/**
+ * 基于配置文件的上传选项
+ */
+export interface UploadWithConfigOptions {
+  /** 存储客户端配置选项 */
+  storageClientOptions?: Partial<StorageClientOptions>;
+  /** 配置文件路径，默认为项目根目录下的vs.config.json */
+  configPath?: string;
+  /** 是否递归上传子目录，默认为true */
+  recursive?: boolean;
+  /** 是否启用压缩，默认为true */
+  enableCompression?: boolean;
+  /** 自定义源路径，如果提供则覆盖配置文件中的uploadPath */
+  customSourcePath?: string;
+  /** 自定义目标路径，如果提供则覆盖配置文件中的目标路径 */
+  customDestination?: string;
+}
+
+/**
+ * 创建存储客户端
+ * @param options - 客户端配置选项
+ * @returns GCP存储客户端实例
+ */
+function createStorageClientFromConfig(options: Partial<StorageClientOptions> = {}): Storage {
+  const { keyFilename, projectId, credentials } = options;
+  
+  // 如果提供了keyFilename，使用密钥文件认证
+  if (keyFilename) {
+    return new Storage({
+      keyFilename
+    });
+  }
+  
+  // 如果提供了credentials，使用凭证对象认证
+  if (credentials) {
+    return new Storage({
+      projectId,
+      credentials
+    });
+  }
+  
+  // 使用应用默认凭证（ADC）进行免密认证
+  return new Storage();
+}
+
+/**
+ * 基于配置文件批量上传文件
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+export async function uploadFilesWithConfig(options: UploadWithConfigOptions = {}): Promise<UploadFilesResult> {
+  const {
+    storageClientOptions = {},
+    configPath,
+    recursive = true,
+    enableCompression = true,
+    customSourcePath,
+    customDestination
+  } = options;
+  
+  try {
+    // 加载配置文件
+    const config: VSConfig = loadConfig(configPath);
+    
+    // 创建存储客户端
+    const storageClient = createStorageClientFromConfig(storageClientOptions);
+    
+    // 获取配置信息
+    const bucketName = getBucketName(config);
+    const sourcePath = customSourcePath || getUploadSourcePath(config);
+    const destination = customDestination || getUploadDestination(config);
+    
+    console.log(`开始上传文件...`);
+    console.log(`源路径: ${sourcePath}`);
+    console.log(`目标桶: ${bucketName}`);
+    console.log(`目标路径: ${destination}`);
+    
+    // 执行批量上传
+    const result = await uploadFiles({
+      bucketName,
+      sourcePath,
+      destination,
+      storageClient,
+      recursive,
+      enableCompression
+    });
+    
+    console.log(`上传完成! 成功: ${result.success.length}, 失败: ${result.failed.length}`);
+    
+    return result;
+  } catch (error) {
+    throw new Error(`基于配置文件的上传失败: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * 获取配置信息（用于调试或显示）
+ * @param configPath - 配置文件路径
+ * @returns 配置信息摘要
+ */
+export function getConfigSummary(configPath?: string): {
+  bucketName: string;
+  sourcePath: string;
+  destination: string;
+} {
+  const config = loadConfig(configPath);
+  
+  return {
+    bucketName: getBucketName(config),
+    sourcePath: getUploadSourcePath(config),
+    destination: getUploadDestination(config)
+  };
+}

package/src/utils/compression.ts

@@ -0,0 +1,61 @@
+/**
+ * 文件压缩工具模块
+ */
+import * as fs from 'fs';
+import { createReadStream, createWriteStream } from 'fs';
+import * as zlib from 'zlib';
+import * as path from 'path';
+import * as util from 'util';
+import * as os from 'os';
+import { pipeline as stream } from 'stream';
+
+const pipeline = util.promisify(stream);
+
+/**
+ * 需要进行GZIP压缩的文件扩展名
+ */
+export const COMPRESSIBLE_EXTENSIONS = [
+  '.js',
+  '.css',
+  '.json',
+  '.html',
+  '.woff'
+];
+
+/**
+ * 检查文件是否需要压缩
+ * @param filePath - 文件路径
+ * @returns 是否需要压缩
+ */
+export function shouldCompressFile(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return COMPRESSIBLE_EXTENSIONS.includes(ext);
+}
+
+/**
+ * 使用GZIP压缩文件
+ * @param inputPath - 输入文件路径
+ * @returns 压缩后的临时文件路径
+ */
+export async function compressFile(inputPath: string): Promise<string> {
+  // 创建临时文件路径
+  const tempDir = os.tmpdir();
+  const fileName = path.basename(inputPath);
+  const outputPath = path.join(tempDir, `${fileName}.gz`);
+  
+  // 创建读取流、GZIP压缩流和写入流
+  const gzip = zlib.createGzip();
+  
+  try {
+    // 使用pipeline进行流处理
+    await pipeline(
+      createReadStream(inputPath),
+      gzip,
+      createWriteStream(outputPath)
+    );
+    
+    return outputPath;
+  } catch (error) {
+    throw new Error(`压缩文件失败: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/test/compression.test.ts

@@ -0,0 +1,88 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { shouldCompressFile, compressFile, COMPRESSIBLE_EXTENSIONS } from '../src/utils/compression';
+
+describe('压缩工具测试', function() {
+  describe('shouldCompressFile', function() {
+    it('应该正确识别可压缩的文件类型', function() {
+      // 测试所有可压缩的扩展名
+      COMPRESSIBLE_EXTENSIONS.forEach(ext => {
+        const filePath = `/path/to/file${ext}`;
+        expect(shouldCompressFile(filePath)).to.be.true;
+      });
+    });
+
+    it('应该正确识别不可压缩的文件类型', function() {
+      const nonCompressibleExtensions = [
+        '.jpg', '.png', '.gif', '.mp4', '.pdf', '.txt'
+      ];
+
+      nonCompressibleExtensions.forEach(ext => {
+        const filePath = `/path/to/file${ext}`;
+        expect(shouldCompressFile(filePath)).to.be.false;
+      });
+    });
+
+    it('应该处理大写扩展名', function() {
+      expect(shouldCompressFile('/path/to/file.JS')).to.be.true;
+      expect(shouldCompressFile('/path/to/file.CSS')).to.be.true;
+      expect(shouldCompressFile('/path/to/file.JSON')).to.be.true;
+    });
+  });
+
+  describe('compressFile', function() {
+    let tempDir: string;
+    let testFilePath: string;
+
+    beforeEach(function() {
+      // 创建临时目录和测试文件
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'compression-test-'));
+      testFilePath = path.join(tempDir, 'test.js');
+      fs.writeFileSync(testFilePath, 'console.log("Hello, World!");');
+    });
+
+    afterEach(function() {
+      // 清理临时文件和目录
+      if (fs.existsSync(tempDir)) {
+        const files = fs.readdirSync(tempDir);
+        files.forEach(file => {
+          fs.unlinkSync(path.join(tempDir, file));
+        });
+        fs.rmdirSync(tempDir);
+      }
+    });
+
+    it('应该成功压缩文件并返回压缩后的文件路径', async function() {
+      const compressedFilePath = await compressFile(testFilePath);
+      
+      // 验证压缩文件存在
+      expect(fs.existsSync(compressedFilePath)).to.be.true;
+      
+      // 验证压缩文件大小小于原文件
+      const originalSize = fs.statSync(testFilePath).size;
+      const compressedSize = fs.statSync(compressedFilePath).size;
+      
+      // 清理压缩文件
+      fs.unlinkSync(compressedFilePath);
+      
+      // 由于GZIP头部信息，对于非常小的文件，压缩后可能会更大
+      // 但对于实际应用中的JS/CSS文件，压缩效果会很明显
+      // 这里我们只验证压缩文件已创建
+      expect(compressedFilePath.endsWith('.gz')).to.be.true;
+    });
+
+    it('应该在文件不存在时抛出错误', async function() {
+      const nonExistentFile = path.join(tempDir, 'non-existent.js');
+      
+      try {
+        await compressFile(nonExistentFile);
+        expect.fail('应该抛出错误');
+      } catch (error) {
+        expect(error).to.exist;
+      }
+    });
+  });
+});

package/test/download.test.ts

@@ -0,0 +1,162 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Storage } from '@google-cloud/storage';
+import { createStorageClient, downloadFile, downloadFiles, ensureDirectoryExists } from '../src/download';
+import { DownloadSuccessResult, DownloadFailedResult } from '../src/types/download';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as util from 'util';
+
+describe('下载功能测试', function() {
+  let storageStub: sinon.SinonStubbedInstance<Storage>;
+  let fsExistsStub: sinon.SinonStub;
+  let fsMkdirStub: sinon.SinonStub;
+  let bucketStub: any;
+  let fileStub: any;
+  
+  beforeEach(function() {
+    // 创建存储客户端的存根
+    storageStub = sinon.createStubInstance(Storage);
+    
+    // 创建文件系统存根
+    fsExistsStub = sinon.stub(fs, 'existsSync');
+    fsMkdirStub = sinon.stub().resolves();
+    sinon.stub(util, 'promisify').returns(fsMkdirStub);
+    
+    // 创建存储桶和文件存根
+    bucketStub = {
+      file: sinon.stub(),
+      getFiles: sinon.stub()
+    };
+    
+    fileStub = {
+      exists: sinon.stub(),
+      download: sinon.stub(),
+      getMetadata: sinon.stub()
+    };
+    
+    // 设置存根行为
+    storageStub.bucket.returns(bucketStub as any);
+    bucketStub.file.returns(fileStub);
+    fileStub.exists.resolves([true]);
+    fileStub.download.resolves([{}]);
+    fileStub.getMetadata.resolves([{ name: 'test.txt' }]);
+    
+    // 默认目录存在
+    fsExistsStub.returns(true);
+    
+    // 设置getFiles的默认行为
+    bucketStub.getFiles.resolves([[
+      { name: 'test.txt' },
+      { name: 'folder/test2.txt' }
+    ], null, { prefixes: ['folder/'] }]);
+  });
+  
+  afterEach(function() {
+    sinon.restore();
+  });
+  
+  describe('createStorageClient()', function() {
+    it('应该使用应用默认凭证创建存储客户端', function() {
+      const storageClient = createStorageClient();
+      expect(storageClient).to.be.instanceOf(Storage);
+    });
+    
+    it('应该使用密钥文件创建存储客户端', function() {
+      const storageClient = createStorageClient({ keyFilename: 'key.json' });
+      expect(storageClient).to.be.instanceOf(Storage);
+    });
+    
+    it('应该使用凭证对象创建存储客户端', function() {
+      const storageClient = createStorageClient({
+        projectId: 'test-project',
+        credentials: {
+          client_email: 'test@example.com',
+          private_key: 'private-key'
+        }
+      });
+      expect(storageClient).to.be.instanceOf(Storage);
+    });
+  });
+  
+  describe('ensureDirectoryExists()', function() {
+    it('应该在目录不存在时创建目录', async function() {
+      fsExistsStub.returns(false);
+      
+      await ensureDirectoryExists('/test/dir');
+      
+      expect(fsExistsStub.calledWith('/test/dir')).to.be.true;
+      expect(fsMkdirStub.calledWith('/test/dir', { recursive: true })).to.be.true;
+    });
+    
+    it('应该在目录已存在时不创建目录', async function() {
+      fsExistsStub.returns(true);
+      
+      await ensureDirectoryExists('/test/dir');
+      
+      expect(fsExistsStub.calledWith('/test/dir')).to.be.true;
+      expect(fsMkdirStub.called).to.be.false;
+    });
+  });
+  
+  describe('downloadFile()', function() {
+    it('应该成功下载文件', async function() {
+      const result = await downloadFile({
+        bucketName: 'test-bucket',
+        sourcePath: 'test.txt',
+        destinationPath: '/test/test.txt',
+        storageClient: storageStub as any
+      });
+      
+      expect(result.success).to.be.true;
+      expect((result as DownloadSuccessResult).file).to.equal('test.txt');
+      expect((result as DownloadSuccessResult).localPath).to.equal('/test/test.txt');
+      expect(storageStub.bucket.calledWith('test-bucket')).to.be.true;
+      expect(bucketStub.file.calledWith('test.txt')).to.be.true;
+      expect(fileStub.download.calledWith({ destination: '/test/test.txt' })).to.be.true;
+    });
+    
+    it('应该在文件不存在时返回失败结果', async function() {
+      fileStub.exists.resolves([false]);
+      
+      const result = await downloadFile({
+        bucketName: 'test-bucket',
+        sourcePath: 'nonexistent.txt',
+        destinationPath: '/test/nonexistent.txt',
+        storageClient: storageStub as any
+      });
+      
+      expect(result.success).to.be.false;
+      expect((result as DownloadFailedResult).file).to.equal('nonexistent.txt');
+      expect((result as DownloadFailedResult).error).to.include('文件不存在');
+    });
+  });
+  
+  describe('downloadFiles()', function() {
+    it('应该成功下载多个文件', async function() {
+      const result = await downloadFiles({
+        bucketName: 'test-bucket',
+        sourcePath: '',
+        destinationPath: '/test',
+        storageClient: storageStub as any
+      });
+      
+      expect(result.success.length).to.equal(2);
+      expect(result.failed.length).to.equal(0);
+      expect(bucketStub.getFiles.called).to.be.true;
+    });
+    
+    it('应该在递归模式下下载子目录', async function() {
+      const result = await downloadFiles({
+        bucketName: 'test-bucket',
+        sourcePath: '',
+        destinationPath: '/test',
+        storageClient: storageStub as any,
+        recursive: true
+      });
+      
+      expect(result.success.length).to.equal(2);
+      expect(bucketStub.getFiles.called).to.be.true;
+    });
+  });
+});

package/test/index.test.js

@@ -0,0 +1,38 @@
+const { expect } = require('chai');
+const { analyzeContent } = require('../src/index');
+
+describe('AI-Yuca 核心功能测试', function() {
+  describe('analyzeContent()', function() {
+    it('应该正确计算文本统计信息', function() {
+      const testText = 'Hello world!\nThis is a test.\nAI-Yuca is awesome.';
+      const result = analyzeContent(testText);
+      
+      expect(result).to.have.property('statistics');
+      expect(result.statistics).to.have.property('charCount').that.equals(testText.length);
+      expect(result.statistics).to.have.property('wordCount').that.equals(9);
+      expect(result.statistics).to.have.property('lineCount').that.equals(3);
+    });
+    
+    it('应该提取关键词', function() {
+      const testText = 'The quick brown fox jumps over the lazy dog. The fox is quick and brown.';
+      const result = analyzeContent(testText);
+      
+      expect(result).to.have.property('keywords');
+      expect(result.keywords).to.be.an('array');
+      
+      // 检查是否包含预期的关键词
+      const keywords = result.keywords.map(k => k.word);
+      expect(keywords).to.include('quick');
+      expect(keywords).to.include('brown');
+    });
+    
+    it('应该处理空文本', function() {
+      const result = analyzeContent('');
+      
+      expect(result.statistics.charCount).to.equal(0);
+      expect(result.statistics.wordCount).to.equal(0);
+      expect(result.statistics.lineCount).to.equal(1); // 空字符串也算一行
+      expect(result.keywords).to.be.an('array').that.is.empty;
+    });
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,39 @@
+import { expect } from 'chai';
+import { analyzeContent } from '../src/index';
+import { AnalysisResult } from '../src/types/analyze';
+
+describe('AI-Yuca 核心功能测试', function() {
+  describe('analyzeContent()', function() {
+    it('应该正确计算文本统计信息', function() {
+      const testText = 'Hello world!\nThis is a test.\nAI-Yuca is awesome.';
+      const result: AnalysisResult = analyzeContent(testText);
+      
+      expect(result).to.have.property('statistics');
+      expect(result.statistics).to.have.property('charCount').that.equals(testText.length);
+      expect(result.statistics).to.have.property('wordCount').that.equals(9);
+      expect(result.statistics).to.have.property('lineCount').that.equals(3);
+    });
+    
+    it('应该提取关键词', function() {
+      const testText = 'The quick brown fox jumps over the lazy dog. The fox is quick and brown.';
+      const result: AnalysisResult = analyzeContent(testText);
+      
+      expect(result).to.have.property('keywords');
+      expect(result.keywords).to.be.an('array');
+      
+      // 检查是否包含预期的关键词
+      const keywords = result.keywords.map((k: { word: string; count: number }) => k.word);
+      expect(keywords).to.include('quick');
+      expect(keywords).to.include('brown');
+    });
+    
+    it('应该处理空文本', function() {
+      const result: AnalysisResult = analyzeContent('');
+      
+      expect(result.statistics.charCount).to.equal(0);
+      expect(result.statistics.wordCount).to.equal(0);
+      expect(result.statistics.lineCount).to.equal(1); // 空字符串也算一行
+      expect(result.keywords).to.be.an('array').that.is.empty;
+    });
+  });
+});

package/test/upload.test.ts

@@ -0,0 +1,131 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Storage } from '@google-cloud/storage';
+import { createStorageClient, uploadFile, uploadFiles } from '../src/upload';
+import { UploadSuccessResult, UploadFailedResult } from '../src/types/upload';
+import { shouldCompressFile, compressFile } from '../src/utils/compression';
+
+// 在测试中使用sinon替代jest进行模拟
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('上传功能测试', function() {
+  let storageStub: sinon.SinonStubbedInstance<Storage>;
+  let fsExistsStub: sinon.SinonStub;
+  let bucketStub: any;
+  
+  beforeEach(function() {
+    // 创建存储客户端的存根
+    storageStub = sinon.createStubInstance(Storage);
+    
+    // 创建文件系统存根
+    fsExistsStub = sinon.stub(fs, 'existsSync');
+    
+    // 创建存储桶存根
+    bucketStub = {
+      upload: sinon.stub().resolves([{
+        getMetadata: sinon.stub().resolves([{
+          name: 'test-file.txt',
+          size: '1024',
+          contentType: 'text/plain',
+          timeCreated: '2023-01-01T00:00:00.000Z'
+        }])
+      }])
+    };
+    
+    storageStub.bucket.returns(bucketStub as any);
+  });
+  
+  afterEach(function() {
+    sinon.restore();
+  });
+  
+  describe('createStorageClient()', function() {
+    it('应该使用应用默认凭证创建存储客户端', function() {
+      const client = createStorageClient({});
+      expect(client).to.be.an.instanceof(Storage);
+    });
+    
+    it('应该使用密钥文件创建存储客户端', function() {
+      const client = createStorageClient({ keyFilename: 'test-key.json' });
+      expect(client).to.be.an.instanceof(Storage);
+    });
+    
+    it('应该使用凭证对象创建存储客户端', function() {
+      const client = createStorageClient({ 
+        credentials: { client_email: 'test@example.com', private_key: 'test-key' } 
+      });
+      expect(client).to.be.an.instanceof(Storage);
+    });
+  });
+  
+  describe('uploadFile()', function() {
+    beforeEach(function() {
+      // 模拟压缩函数
+      (shouldCompressFile as any) = sinon.stub().returns(false);
+      (compressFile as any) = sinon.stub().resolves('test-file.txt.gz');
+      
+      // 模拟文件系统
+      fsExistsStub.withArgs('test-file.txt.gz').returns(true);
+    });
+    
+    it('应该在文件不存在时返回失败结果', async function() {
+      fsExistsStub.withArgs('non-existent-file.txt').returns(false);
+      
+      const result = await uploadFile({
+        bucketName: 'test-bucket',
+        filePath: 'non-existent-file.txt',
+        storageClient: storageStub as unknown as Storage
+      });
+      
+      expect(result.success).to.be.false;
+      expect(result).to.have.property('error').that.includes('文件不存在');
+    });
+    
+    it('应该成功上传文件（不压缩）', async function() {
+      fsExistsStub.withArgs('test-file.txt').returns(true);
+      
+      const result = await uploadFile({
+        bucketName: 'test-bucket',
+        filePath: 'test-file.txt',
+        storageClient: storageStub as unknown as Storage
+      });
+      
+      expect(result.success).to.be.true;
+      expect(result).to.have.property('file').that.equals('test-file.txt');
+      expect(result).to.have.property('url').that.includes('test-bucket/test-file.txt');
+    });
+    
+    it('应该成功上传压缩文件', async function() {
+       fsExistsStub.withArgs('test-file.js').returns(true);
+       (shouldCompressFile as any).returns(true);
+       
+       const result = await uploadFile({
+         bucketName: 'test-bucket',
+         filePath: 'test-file.js',
+         storageClient: storageStub as unknown as Storage,
+         enableCompression: true
+       });
+       
+       expect((shouldCompressFile as any).calledWith('test-file.js')).to.be.true;
+       expect((compressFile as any).calledWith('test-file.js')).to.be.true;
+       expect(result.success).to.be.true;
+     });
+    
+    it('应该在禁用压缩时不压缩文件', async function() {
+       fsExistsStub.withArgs('test-file.js').returns(true);
+       (shouldCompressFile as any).returns(true);
+       
+       const result = await uploadFile({
+         bucketName: 'test-bucket',
+         filePath: 'test-file.js',
+         storageClient: storageStub as unknown as Storage,
+         enableCompression: false
+       });
+       
+       // 不应该调用压缩函数
+       expect((compressFile as any).called).to.be.false;
+       expect(result.success).to.be.true;
+     });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "CommonJS",
+    "lib": ["ES2018"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "bin/**/*", "test/**/*"],
+  "exclude": ["node_modules", "dist"]
+}