vectra 0.12.2 → 0.14.0

package/src/types.ts

@@ -4,17 +4,17 @@
  * An AI model that can be used to create embeddings.
  */
 export interface EmbeddingsModel {
-    /**
-     * Maximum number of tokens
-     */
-    readonly maxTokens: number;
-
-    /**
-     * Creates embeddings for the given inputs.
-     * @param inputs Text inputs to create embeddings for.
-     * @returns A `EmbeddingsResponse` with a status and the generated embeddings or a message when an error occurs.
-     */
-    createEmbeddings(inputs: string|string[]): Promise<EmbeddingsResponse>;
+  /**
+   * Maximum number of tokens
+   */
+  readonly maxTokens: number;
+
+  /**
+   * Creates embeddings for the given inputs.
+   * @param inputs Text inputs to create embeddings for.
+   * @returns A `EmbeddingsResponse` with a status and the generated embeddings or a message when an error occurs.
+   */
+  createEmbeddings(inputs: string | string[]): Promise<EmbeddingsResponse>;
 }
 
 /**
@@ -30,147 +30,155 @@ export type EmbeddingsResponseStatus = 'success' | 'error' | 'rate_limited' | 'c
  * Response returned by a `EmbeddingsClient`.
  */
 export interface EmbeddingsResponse {
-    /**
-     * Status of the embeddings response.
-     */
-    status: EmbeddingsResponseStatus;
-
-    /**
-     * Optional. Embeddings for the given inputs.
-     */
-    output?: number[][];
-
-    /**
-     * Optional. Message when status is not equal to `success`.
-     */
-    message?: string;
-
-    /**
-     * Optional. Model used to create the embeddings.
-     */
-    model?: string;
-
-    /**
-     * Optional. Usage statistics for the request.
-     */
-    usage?: Record<string, any>;
+  /**
+   * Status of the embeddings response.
+   */
+  status: EmbeddingsResponseStatus;
+
+  /**
+   * Optional. Embeddings for the given inputs.
+   */
+  output?: number[][];
+
+  /**
+   * Optional. Message when status is not equal to `success`.
+   */
+  message?: string;
+
+  /**
+   * Optional. Model used to create the embeddings.
+   */
+  model?: string;
+
+  /**
+   * Optional. Usage statistics for the request.
+   */
+  usage?: Record<string, any>;
 }
 
 export interface TextChunk {
-    text: string;
-    tokens: number[];
-    startPos: number;
-    endPos: number;
-    startOverlap: number[];
-    endOverlap: number[];
+  text: string;
+  tokens: number[];
+  startPos: number;
+  endPos: number;
+  startOverlap: number[];
+  endOverlap: number[];
 }
 
 export interface TextFetcher {
-    fetch(uri: string, onDocument: (uri: string, text: string, docType?: string) => Promise<boolean>): Promise<boolean>;
+  fetch(uri: string, onDocument: (uri: string, text: string, docType?: string) => Promise<boolean>): Promise<boolean>;
 }
 
 export interface IndexStats {
-    version: number;
-    metadata_config: {
-        indexed?: string[];
-    };
-    items: number;
+  version: number;
+  metadata_config: {
+    indexed?: string[];
+  };
+  items: number;
 }
 
-export interface IndexItem<TMetadata = Record<string,MetadataTypes>> {
-    id: string;
-    metadata: TMetadata;
-    vector: number[];
-    norm: number;
-    metadataFile?: string;
+export interface IndexItem<TMetadata = Record<string, MetadataTypes>> {
+  id: string;
+  metadata: TMetadata;
+  vector: number[];
+  norm: number;
+  metadataFile?: string;
 }
 
 export interface MetadataFilter {
 
-    /**
-     * Equal to (number, string, boolean)
-     */
-    '$eq'?: number|string|boolean;
-
-    /**
-     * Not equal to (number, string, boolean)
-     */
-    '$ne'?: number|string|boolean;
-
-    /**
-     * Greater than (number)
-     */
-    '$gt'?: number;
-
-    /**
-     * Greater than or equal to (number)
-     */
-    '$gte'?: number;
-
-    /**
-     * Less than (number)
-     */
-    '$lt'?: number;
-
-    /**
-     * Less than or equal to (number)
-     */
-    '$lte'?: number;
-
-    /**
-     * In array (string or number)
-     */
-    '$in'?: (number|string)[];
-
-    /**
-     * Not in array (string or number)
-     */
-    '$nin'?: (number|string)[];
-
-    /**
-     * AND (MetadataFilter[])
-     */
-    '$and'?: MetadataFilter[];
-
-    /**
-     * OR (MetadataFilter[])
-     */
-    '$or'?: MetadataFilter[];
-
-    [key: string]: unknown;
+  /**
+   * Equal to (number, string, boolean)
+   */
+  '$eq'?: number | string | boolean;
+
+  /**
+   * Not equal to (number, string, boolean)
+   */
+  '$ne'?: number | string | boolean;
+
+  /**
+   * Greater than (number)
+   */
+  '$gt'?: number;
+
+  /**
+   * Greater than or equal to (number)
+   */
+  '$gte'?: number;
+
+  /**
+   * Less than (number)
+   */
+  '$lt'?: number;
+
+  /**
+   * Less than or equal to (number)
+   */
+  '$lte'?: number;
+
+  /**
+   * In array (string or number)
+   */
+  '$in'?: (number | string)[];
+
+  /**
+   * Not in array (string or number)
+   */
+  '$nin'?: (number | string)[];
+
+  /**
+   * AND (MetadataFilter[])
+   */
+  '$and'?: MetadataFilter[];
+
+  /**
+   * OR (MetadataFilter[])
+   */
+  '$or'?: MetadataFilter[];
+
+  [key: string]: unknown;
 }
 
-export type MetadataTypes = number|string|boolean;
+export type MetadataTypes = number | string | boolean;
 
-export interface QueryResult<TMetadata = Record<string,MetadataTypes>> {
-    item: IndexItem<TMetadata>;
-    score: number;
+export interface QueryResult<TMetadata = Record<string, MetadataTypes>> {
+  item: IndexItem<TMetadata>;
+  score: number;
 }
 
 export interface Tokenizer {
-    decode(tokens: number[]): string;
-    encode(text: string): number[];
+  decode(tokens: number[]): string;
+  encode(text: string): number[];
 }
 
 export interface DocumentChunkMetadata {
-    documentId: string;
-    startPos: number;
-    endPos: number;
-    [key: string]: MetadataTypes;
+  documentId: string;
+  startPos: number;
+  endPos: number;
+  [key: string]: MetadataTypes;
 }
 
 export interface DocumentCatalogStats {
+  version: number;
+  documents: number;
+  chunks: number;
+  metadata_config: {
+    indexed?: string[];
+  };
+}
+
+export interface DocumentTextSection {
+  text: string;
+  tokenCount: number;
+  score: number;
+  isBm25: boolean;
+}
+
+export interface IndexData {
     version: number;
-    documents: number;
-    chunks: number;
     metadata_config: {
         indexed?: string[];
     };
+    items: IndexItem[];
 }
-
-export interface DocumentTextSection {
-    text: string;
-    tokenCount: number;
-    score: number;
-    isBm25: boolean;
-}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './pathUtils';

package/src/utils/pathUtils.ts

@@ -0,0 +1,106 @@
+/**
+ * Universal path utilities that work in Node, Browser, and Electron.
+ * Replaces Node's 'path' module for cross-platform compatibility.
+ */
+export const pathUtils = {
+    /**
+     * Path separator. Always '/' for consistency across platforms.
+     */
+    sep: '/' as const,
+    /**
+     * Join path segments together.
+     */
+    join(...parts: string[]): string {
+        return parts
+            .map((part, i) => {
+                if (i === 0) return part.replace(/[/\\]+$/, '');
+                return part.replace(/^[/\\]+|[/\\]+$/g, '');
+            })
+            .filter(Boolean)
+            .join('/');
+    },
+
+    /**
+     * Get the last portion of a path.
+     */
+    basename(filePath: string, ext?: string): string {
+        const base = filePath.split(/[/\\]/).pop() || '';
+        if (ext && base.endsWith(ext)) {
+            return base.slice(0, -ext.length);
+        }
+        return base;
+    },
+
+    /**
+     * Get the directory name of a path.
+     */
+    dirname(filePath: string): string {
+        const parts = filePath.split(/[/\\]/);
+        parts.pop();
+        return parts.join('/') || '.';
+    },
+
+    /**
+     * Get the extension of the path.
+     */
+    extname(filePath: string): string {
+        const base = pathUtils.basename(filePath);
+        const dotIndex = base.lastIndexOf('.');
+        return dotIndex > 0 ? base.slice(dotIndex) : '';
+    },
+
+    /**
+     * Normalize a path, resolving '..' and '.' segments.
+     */
+    normalize(filePath: string): string {
+        const isAbsolute = filePath.startsWith('/') || /^[a-zA-Z]:/.test(filePath);
+        const parts = filePath.split(/[/\\]/);
+        const result: string[] = [];
+
+        for (const part of parts) {
+            if (part === '..') {
+                result.pop();
+            } else if (part !== '.' && part !== '') {
+                result.push(part);
+            }
+        }
+
+        return (isAbsolute && !(/^[a-zA-Z]:/.test(filePath)) ? '/' : '') + result.join('/');
+    },
+
+    /**
+     * Determine if a path is absolute.
+     */
+    isAbsolute(filePath: string): boolean {
+        return filePath.startsWith('/') || /^[a-zA-Z]:[/\\]/.test(filePath);
+    },
+
+    /**
+     * Get the relative path from one path to another.
+     */
+    relative(from: string, to: string): string {
+        const fromParts = pathUtils.normalize(from).split('/').filter(Boolean);
+        const toParts = pathUtils.normalize(to).split('/').filter(Boolean);
+
+        // Find common prefix
+        let commonLength = 0;
+        while (
+            commonLength < fromParts.length &&
+            commonLength < toParts.length &&
+            fromParts[commonLength] === toParts[commonLength]
+        ) {
+            commonLength++;
+        }
+
+        // Build relative path
+        const upCount = fromParts.length - commonLength;
+        const relativeParts = [
+            ...Array(upCount).fill('..'),
+            ...toParts.slice(commonLength)
+        ];
+
+        return relativeParts.join('/') || '.';
+    }
+};
+
+export default pathUtils;

package/src/vectra-cli.generate.spec.ts

@@ -0,0 +1,72 @@
+import * as assert from 'assert';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+describe('vectra generate', () => {
+    let tmpDir: string;
+    const projectRoot = process.cwd();
+
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vectra-gen-'));
+    });
+
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+
+    const languages = ['python', 'csharp', 'rust', 'go', 'java', 'typescript'] as const;
+
+    for (const lang of languages) {
+        it(`should generate ${lang} bindings`, async () => {
+            const outputDir = path.join(tmpDir, lang);
+            const binPath = path.join(projectRoot, 'bin', 'vectra.js');
+            execSync(`node "${binPath}" generate --language ${lang} --output "${outputDir}"`, {
+                cwd: projectRoot,
+                timeout: 15000,
+            });
+
+            // Verify proto file was copied
+            const protoPath = path.join(outputDir, 'vectra_service.proto');
+            const protoStat = await fs.stat(protoPath);
+            assert.ok(protoStat.isFile(), 'vectra_service.proto should exist');
+
+            // Verify README was copied
+            const readmePath = path.join(outputDir, 'README.md');
+            const readmeStat = await fs.stat(readmePath);
+            assert.ok(readmeStat.isFile(), 'README.md should exist');
+
+            // Language-specific checks
+            const files = await fs.readdir(outputDir);
+            if (lang === 'python') {
+                assert.ok(files.includes('vectra_client.py'), 'should have vectra_client.py');
+            } else if (lang === 'csharp') {
+                assert.ok(files.includes('VectraClient.cs'), 'should have VectraClient.cs');
+            } else if (lang === 'rust') {
+                assert.ok(files.includes('lib.rs'), 'should have lib.rs');
+                assert.ok(files.includes('Cargo.toml'), 'should have Cargo.toml');
+                assert.ok(files.includes('build.rs'), 'should have build.rs');
+            } else if (lang === 'go') {
+                assert.ok(files.includes('vectra_client.go'), 'should have vectra_client.go');
+            } else if (lang === 'java') {
+                assert.ok(files.includes('VectraClient.java'), 'should have VectraClient.java');
+            } else if (lang === 'typescript') {
+                assert.ok(files.includes('VectraClient.ts'), 'should have VectraClient.ts');
+            }
+        });
+    }
+
+    it('should create output directory if it does not exist', async () => {
+        const outputDir = path.join(tmpDir, 'nested', 'deep', 'dir');
+        const binPath = path.join(projectRoot, 'bin', 'vectra.js');
+        execSync(`node "${binPath}" generate --language python --output "${outputDir}"`, {
+            cwd: projectRoot,
+            timeout: 15000,
+        });
+
+        const files = await fs.readdir(outputDir);
+        assert.ok(files.includes('vectra_service.proto'));
+        assert.ok(files.includes('vectra_client.py'));
+    });
+});