@ngao/search 0.1.0 → 0.1.2

package/tests/unit/search-integration.test.ts

@@ -0,0 +1,256 @@
+import { NgaoSearchService } from '../../src/backend/services/ngao-search-service';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('Search Integration Tests', () => {
+  let service: NgaoSearchService;
+  let testProjectDir: string;
+  let testCacheDir: string;
+
+  beforeAll(async () => {
+    // Create a temporary test project directory
+    testProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ngao-search-test-'));
+    testCacheDir = path.join(testProjectDir, '.ngao');
+
+    // Create test files to index
+    const srcDir = path.join(testProjectDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+
+    // Create a sample TypeScript file
+    fs.writeFileSync(
+      path.join(srcDir, 'example.ts'),
+      `
+export function calculateSum(a: number, b: number): number {
+  return a + b;
+}
+
+export class Calculator {
+  multiply(x: number, y: number): number {
+    return x * y;
+  }
+
+  divide(x: number, y: number): number {
+    if (y === 0) throw new Error('Division by zero');
+    return x / y;
+  }
+}
+
+export const PI = 3.14159;
+`
+    );
+
+    // Create a sample JavaScript file
+    fs.writeFileSync(
+      path.join(srcDir, 'utils.js'),
+      `
+function greet(name) {
+  return \`Hello, \${name}!\`;
+}
+
+function farewell(name) {
+  return \`Goodbye, \${name}!\`;
+}
+
+module.exports = { greet, farewell };
+`
+    );
+
+    // Create a sample Markdown file
+    fs.writeFileSync(
+      path.join(srcDir, 'README.md'),
+      `
+# Test Project
+
+This is a test project for ngao-search integration testing.
+
+## Features
+
+- Fast semantic search
+- Multi-language support
+- Indexing with embeddings
+
+## Usage
+
+\`\`\`typescript
+const service = new NgaoSearchService();
+await service.index('./src');
+const results = await service.search({ query: 'calculate' });
+\`\`\`
+`
+    );
+
+    // Create service instance with test project
+    service = new NgaoSearchService(testProjectDir);
+  });
+
+  afterAll(() => {
+    // Clean up test files
+    if (fs.existsSync(testProjectDir)) {
+      fs.rmSync(testProjectDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Index and Search Workflow', () => {
+    it('should index a directory and return stats', async () => {
+      const indexResult = await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      expect(indexResult.success).toBe(true);
+      if (indexResult.success) {
+        expect(indexResult.stats).toBeDefined();
+        expect(indexResult.stats.totalFiles).toBeGreaterThan(0);
+        expect(indexResult.stats.totalBlocks).toBeGreaterThan(0);
+      }
+    });
+
+    it('should search for indexed content after indexing', async () => {
+      // First ensure index is populated
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      // Search for something that should be indexed
+      const searchResult = await service.search({
+        query: 'calculate',
+        maxResults: 5,
+      });
+
+      expect(searchResult.success).toBe(true);
+      if (searchResult.success) {
+        expect(searchResult.resultCount).toBeGreaterThanOrEqual(0);
+        expect(searchResult.results).toBeDefined();
+        expect(Array.isArray(searchResult.results)).toBe(true);
+      }
+    });
+
+    it('should return results with expected structure', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const searchResult = await service.search({
+        query: 'function',
+        maxResults: 10,
+      });
+
+      if (searchResult.success && searchResult.results && searchResult.results.length > 0) {
+        const result = searchResult.results[0];
+        expect(result).toHaveProperty('rank');
+        expect(result).toHaveProperty('score');
+        expect(result).toHaveProperty('type');
+        expect(result).toHaveProperty('name');
+        expect(result).toHaveProperty('file');
+        expect(result).toHaveProperty('lineRange');
+        expect(result).toHaveProperty('scope');
+        expect(result).toHaveProperty('content');
+      }
+    });
+
+    it('should get statistics about indexed content', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const stats = await service.getStats();
+
+      expect(stats.success).toBe(true);
+      if (stats.success) {
+        expect(stats.stats).toBeDefined();
+        expect(stats.stats.totalFiles).toBeGreaterThan(0);
+        expect(stats.stats.totalBlocks).toBeGreaterThan(0);
+        expect(stats.stats.lastUpdated).toBeDefined();
+      }
+    });
+
+    it('should create a session and track search history', () => {
+      const sessionResponse = service.createSession();
+
+      expect(sessionResponse.sessionId).toBeDefined();
+      expect(typeof sessionResponse.sessionId).toBe('string');
+      expect(sessionResponse.sessionId.length).toBeGreaterThan(0);
+    });
+
+    it('should track searches in session history', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      // Create a session
+      const sessionResponse = service.createSession();
+      const sessionId = sessionResponse.sessionId;
+
+      // Perform a search with session ID
+      const searchResult = await service.search({
+        query: 'test',
+        sessionId,
+      });
+
+      expect(searchResult.success).toBe(true);
+
+      // Get search history
+      const historyResult = service.getSearchHistory({ sessionId });
+
+      expect(historyResult.success).toBe(true);
+      if (historyResult.success && historyResult.data) {
+        expect(Array.isArray(historyResult.data)).toBe(true);
+        expect((historyResult.data as any[]).length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should handle searches with no results gracefully', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const searchResult = await service.search({
+        query: 'xyzabc123nonexistentquery',
+        maxResults: 5,
+      });
+
+      expect(searchResult.success).toBe(true);
+      if (searchResult.success) {
+        expect(searchResult.resultCount).toBe(0);
+        expect(Array.isArray(searchResult.results)).toBe(true);
+      }
+    });
+
+    it('should list indexed directories', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const listResult = await service.listIndexedDirs();
+
+      expect(listResult.success).toBe(true);
+      if (listResult.success && listResult.data) {
+        expect(Array.isArray(listResult.data)).toBe(true);
+      }
+    });
+
+    it('should get index information', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const infoResult = await service.getIndexInfo();
+
+      expect(infoResult.success).toBe(true);
+      if (infoResult.success) {
+        expect(infoResult.data).toBeDefined();
+      }
+    });
+  });
+
+  describe('Cache Management', () => {
+    it('should use cache directory for indexed data', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      // Check that cache directory was created
+      expect(fs.existsSync(testCacheDir)).toBe(true);
+    });
+  });
+});

package/tests/unit/services.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=services.test.d.ts.map

package/tests/unit/services.test.d.ts.map

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

package/tests/unit/services.test.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ngao_search_service_1 = require("../../src/backend/services/ngao-search-service");
+describe('NgaoSearchService', () => {
+    it('should be defined', () => {
+        expect(ngao_search_service_1.NgaoSearchService).toBeDefined();
+    });
+});
+//# sourceMappingURL=services.test.js.map

package/tests/unit/services.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.test.js","sourceRoot":"","sources":["services.test.ts"],"names":[],"mappings":";;AAAA,wFAAkF;AAElF,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IACjC,EAAE,CAAC,mBAAmB,EAAE,GAAG,EAAE;QAC3B,MAAM,CAAC,uCAAiB,CAAC,CAAC,WAAW,EAAE,CAAA;IACzC,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/tests/unit/services.test.ts

@@ -0,0 +1,7 @@
+import { NgaoSearchService } from '../../src/backend/services/ngao-search-service'
+
+describe('NgaoSearchService', () => {
+  it('should be defined', () => {
+    expect(NgaoSearchService).toBeDefined()
+  })
+})

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "types": ["node", "jest"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/webpack.backend.config.js

@@ -0,0 +1,60 @@
+const path = require('path');
+const nodeExternals = require('webpack-node-externals');
+
+const baseConfig = {
+  target: 'node',
+  entry: './src/main.ts',
+  resolve: {
+    extensions: ['.ts', '.tsx', '.js', '.jsx'],
+    alias: {
+      '@': path.resolve(__dirname, 'src'),
+    },
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              configFile: 'tsconfig.json',
+            },
+          },
+        ],
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  devtool: process.env.NODE_ENV === 'production' ? false : 'source-map',
+  optimization: {
+    minimize: process.env.NODE_ENV === 'production',
+  },
+};
+
+// MCP CLI build - all dependencies included (except native modules)
+const config = {
+  ...baseConfig,
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'main.js',
+    libraryTarget: 'commonjs2',
+  },
+  externals: [
+    // Keep external native binary modules that can't be bundled
+    ({ request }, callback) => {
+      // Allow .node files to be loaded at runtime
+      if (request && request.endsWith('.node')) {
+        return callback(null, `commonjs ${request}`);
+      }
+      // Keep native module packages external
+      if (request && /^(@xenova\/transformers|onnxruntime-node|sharp|@lancedb\/lancedb)/.test(request)) {
+        return callback(null, `commonjs ${request}`);
+      }
+      callback();
+    },
+  ],
+};
+
+module.exports = config;

package/webpack.config.js

@@ -0,0 +1,34 @@
+const path = require('path');
+
+module.exports = {
+  entry: './src/main.ts',
+  target: 'node',
+  mode: 'production',
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+      {
+        test: /\.node$/,
+        loader: 'node-loader',
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.js', '.node'],
+  },
+  output: {
+    filename: 'main.js',
+    path: path.resolve(__dirname, 'dist'),
+  },
+  externals: {
+    '@ngao/search-core': 'commonjs @ngao/search-core',
+    '@modelcontextprotocol/sdk': 'commonjs @modelcontextprotocol/sdk',
+    '@lancedb/lancedb': 'commonjs @lancedb/lancedb',
+    'express': 'commonjs express',
+    'chokidar': 'commonjs chokidar',
+  },
+};

package/models/Xenova/all-MiniLM-L6-v2/config.json

@@ -1,25 +0,0 @@
-{
-  "_name_or_path": "sentence-transformers/all-MiniLM-L6-v2",
-  "architectures": [
-    "BertModel"
-  ],
-  "attention_probs_dropout_prob": 0.1,
-  "classifier_dropout": null,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 384,
-  "initializer_range": 0.02,
-  "intermediate_size": 1536,
-  "layer_norm_eps": 1e-12,
-  "max_position_embeddings": 512,
-  "model_type": "bert",
-  "num_attention_heads": 12,
-  "num_hidden_layers": 6,
-  "pad_token_id": 0,
-  "position_embedding_type": "absolute",
-  "transformers_version": "4.29.2",
-  "type_vocab_size": 2,
-  "use_cache": true,
-  "vocab_size": 30522
-}