@ngao/search 0.1.1 → 0.1.2

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(xargs:*)",
+      "Bash(npm run build:*)",
+      "Bash(npm test:*)"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngao/search",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Search engine CLI and API with file watching",
   "license": "Apache-2.0",
   "author": "Ngao Search Contributors",

package/tests/unit/agent-tools.test.ts

@@ -0,0 +1,454 @@
+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('Agent Tools Functionality', () => {
+  let service: NgaoSearchService;
+  let testProjectDir: string;
+
+  beforeAll(async () => {
+    // Create a temporary test project directory
+    testProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ngao-agent-test-'));
+
+    // Create test files to index
+    const srcDir = path.join(testProjectDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+
+    // Create sample files
+    fs.writeFileSync(
+      path.join(srcDir, 'auth.ts'),
+      `
+export function authenticate(username: string, password: string): boolean {
+  if (!username || !password) return false;
+  return validateCredentials(username, password);
+}
+
+function validateCredentials(user: string, pass: string): boolean {
+  // Validation logic here
+  return true;
+}
+
+export class AuthService {
+  private token: string = '';
+
+  login(credentials: any): void {
+    // Login implementation
+    this.token = generateToken();
+  }
+
+  logout(): void {
+    this.token = '';
+  }
+
+  private generateToken(): string {
+    return 'token-' + Date.now();
+  }
+}
+`
+    );
+
+    fs.writeFileSync(
+      path.join(srcDir, 'database.ts'),
+      `
+export async function queryDatabase(sql: string): Promise<any[]> {
+  const connection = await createConnection();
+  try {
+    const results = await connection.query(sql);
+    return results;
+  } finally {
+    await connection.close();
+  }
+}
+
+async function createConnection(): Promise<any> {
+  return {
+    query: async (sql: string) => [],
+    close: async () => {}
+  };
+}
+
+export class DatabasePool {
+  private pool: any[] = [];
+
+  async getConnection() {
+    return this.pool.pop() || await createConnection();
+  }
+
+  releaseConnection(conn: any) {
+    this.pool.push(conn);
+  }
+}
+`
+    );
+
+    fs.writeFileSync(
+      path.join(srcDir, 'API.md'),
+      `
+# API Documentation
+
+## Authentication Endpoints
+
+### POST /auth/login
+Authenticates a user with credentials.
+
+### POST /auth/logout
+Logs out the current user.
+
+### GET /auth/profile
+Returns the authenticated user profile.
+
+## Database Endpoints
+
+### GET /api/users
+Retrieves all users from the database.
+
+### POST /api/users
+Creates a new user in the database.
+
+### PUT /api/users/:id
+Updates a user record.
+
+### DELETE /api/users/:id
+Deletes a user record.
+`
+    );
+
+    // 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('Agent Tool: search', () => {
+    beforeAll(async () => {
+      // Index the project before running search tests
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+    });
+
+    it('should perform semantic search', async () => {
+      const result = await service.search({
+        query: 'user authentication',
+        maxResults: 10,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(typeof result.resultCount).toBe('number');
+        expect(typeof result.executionTimeMs).toBe('number');
+        expect(Array.isArray(result.results)).toBe(true);
+      }
+    });
+
+    it('should respect maxResults parameter', async () => {
+      const result = await service.search({
+        query: 'authenticate',
+        maxResults: 3,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.results.length).toBeLessThanOrEqual(3);
+      }
+    });
+
+    it('should track search in session', async () => {
+      const session = service.createSession();
+      const sessionId = session.sessionId;
+
+      const searchResult = await service.search({
+        query: 'database',
+        sessionId,
+      });
+
+      expect(searchResult.success).toBe(true);
+
+      const history = service.getSearchHistory({ sessionId });
+      expect(history.success).toBe(true);
+      if (history.success && history.data) {
+        expect((history.data as any[]).length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should return ranked results with relevance scores', async () => {
+      const result = await service.search({
+        query: 'login',
+        maxResults: 5,
+      });
+
+      if (result.success && result.results && result.results.length > 0) {
+        const firstResult = result.results[0];
+        expect(firstResult.rank).toBeDefined();
+        expect(typeof firstResult.score).toBe('number');
+        expect(firstResult.score).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('Agent Tool: index', () => {
+    it('should index a directory successfully', async () => {
+      const result = await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.message).toBeDefined();
+        expect(result.stats).toBeDefined();
+        expect(result.stats.totalFiles).toBeGreaterThan(0);
+        expect(result.stats.totalBlocks).toBeGreaterThan(0);
+      }
+    });
+
+    it('should return indexing statistics', async () => {
+      const result = await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      if (result.success) {
+        const stats = result.stats;
+        expect(stats.totalFiles).toBeGreaterThanOrEqual(0);
+        expect(stats.totalBlocks).toBeGreaterThanOrEqual(0);
+        expect(stats.lastUpdated).toBeDefined();
+      }
+    });
+  });
+
+  describe('Agent Tool: get_stats', () => {
+    beforeAll(async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+    });
+
+    it('should return global indexing statistics', async () => {
+      const result = await service.getStats();
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.stats).toBeDefined();
+        expect(typeof result.stats.totalFiles).toBe('number');
+        expect(typeof result.stats.totalBlocks).toBe('number');
+        expect(result.stats.lastUpdated).toBeDefined();
+      }
+    });
+
+    it('should show that files have been indexed', async () => {
+      const result = await service.getStats();
+
+      if (result.success) {
+        expect(result.stats.totalBlocks).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('Agent Tool: get_index_info', () => {
+    beforeAll(async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+    });
+
+    it('should return detailed index information', async () => {
+      const result = await service.getIndexInfo();
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toBeDefined();
+      }
+    });
+  });
+
+  describe('Agent Tool: get_file_statistics', () => {
+    beforeAll(async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+    });
+
+    it('should return file statistics', async () => {
+      const result = await service.getFileStatistics({});
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toBeDefined();
+      }
+    });
+  });
+
+  describe('Agent Tool: get_search_history', () => {
+    it('should retrieve search history for a session', async () => {
+      const session = service.createSession();
+      const sessionId = session.sessionId;
+
+      // Perform searches
+      await service.search({ query: 'auth', sessionId });
+      await service.search({ query: 'database', sessionId });
+
+      // Get history
+      const result = service.getSearchHistory({ sessionId });
+
+      expect(result.success).toBe(true);
+      if (result.success && result.data) {
+        expect(Array.isArray(result.data)).toBe(true);
+        expect((result.data as any[]).length).toBeGreaterThanOrEqual(2);
+      }
+    });
+
+    it('should include query details in search history', async () => {
+      const session = service.createSession();
+      const sessionId = session.sessionId;
+
+      await service.search({ query: 'login', sessionId });
+
+      const result = service.getSearchHistory({ sessionId });
+
+      if (result.success && result.data) {
+        const data = result.data as any[];
+        if (data.length > 0) {
+          const entry = data[0];
+          expect(entry).toHaveProperty('query');
+          expect(entry).toHaveProperty('timestamp');
+          expect(entry).toHaveProperty('resultCount');
+          expect(entry).toHaveProperty('executionTimeMs');
+        }
+      }
+    });
+
+    it('should return error for invalid session', () => {
+      const result = service.getSearchHistory({ sessionId: 'invalid-session-id' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBeDefined();
+      }
+    });
+  });
+
+  describe('Agent Tool: start_reindex', () => {
+    it('should initiate reindex operation', async () => {
+      const result = await service.startReindex({
+        dirPath: path.join(testProjectDir, 'src'),
+        mode: 'incremental',
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.reindexId).toBeDefined();
+        expect(result.data.dirPath).toBe(path.join(testProjectDir, 'src'));
+      }
+    });
+  });
+
+  describe('Agent Tool: get_reindex_status', () => {
+    it('should return reindex operation status', async () => {
+      const startResult = await service.startReindex({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      if (startResult.success) {
+        const statusResult = service.getReindexStatus({
+          reindexId: startResult.data.reindexId,
+        });
+
+        expect(statusResult.success).toBe(true);
+        if (statusResult.success) {
+          expect(statusResult.data).toBeDefined();
+        }
+      }
+    });
+  });
+
+  describe('Agent Tool: list_indexed_dirs', () => {
+    beforeAll(async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+    });
+
+    it('should list indexed directories', async () => {
+      const result = await service.listIndexedDirs();
+
+      expect(result.success).toBe(true);
+      if (result.success && result.data) {
+        expect(Array.isArray(result.data)).toBe(true);
+      }
+    });
+  });
+
+  describe('Session Management (Agent Support)', () => {
+    it('should create a unique session per request', () => {
+      const session1 = service.createSession();
+      const session2 = service.createSession();
+
+      expect(session1.sessionId).not.toEqual(session2.sessionId);
+    });
+
+    it('should maintain separate search history per session', async () => {
+      await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+
+      const session1 = service.createSession();
+      const session2 = service.createSession();
+
+      await service.search({ query: 'auth', sessionId: session1.sessionId });
+      await service.search({ query: 'database', sessionId: session2.sessionId });
+
+      const history1 = service.getSearchHistory({ sessionId: session1.sessionId });
+      const history2 = service.getSearchHistory({ sessionId: session2.sessionId });
+
+      if (history1.success && history1.data && history2.success && history2.data) {
+        expect((history1.data as any[]).length).toBeGreaterThan(0);
+        expect((history2.data as any[]).length).toBeGreaterThan(0);
+        expect(history1.data).not.toEqual(history2.data);
+      }
+    });
+  });
+
+  describe('Agent Workflow', () => {
+    it('should complete full agent workflow: index -> search -> stats -> history', async () => {
+      // Step 1: Create session
+      const session = service.createSession();
+      const sessionId = session.sessionId;
+
+      // Step 2: Index directory
+      const indexResult = await service.index({
+        dirPath: path.join(testProjectDir, 'src'),
+      });
+      expect(indexResult.success).toBe(true);
+
+      // Step 3: Perform search with session
+      const searchResult = await service.search({
+        query: 'authenticate user',
+        sessionId,
+      });
+      expect(searchResult.success).toBe(true);
+
+      // Step 4: Get stats
+      const statsResult = await service.getStats();
+      expect(statsResult.success).toBe(true);
+      if (statsResult.success) {
+        expect(statsResult.stats.totalBlocks).toBeGreaterThan(0);
+      }
+
+      // Step 5: Get search history
+      const historyResult = service.getSearchHistory({ sessionId });
+      expect(historyResult.success).toBe(true);
+      if (historyResult.success && historyResult.data) {
+        expect((historyResult.data as any[]).length).toBeGreaterThan(0);
+      }
+
+      // Step 6: Get index info
+      const infoResult = await service.getIndexInfo();
+      expect(infoResult.success).toBe(true);
+    });
+  });
+});

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);
+    });
+  });
+});