@medyll/idae-chroma 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/database/chromaClient.d.ts

@@ -0,0 +1,22 @@
+import { QueryParams } from 'chromadb';
+type Metadata = Record<string, string | number | boolean>;
+export type ChromaQueryParams = QueryParams;
+export declare class IdaeChromaClient {
+    private client;
+    private collection;
+    private collectionName;
+    constructor(config?: {
+        path: string;
+    });
+    initCollection(collectionName: string): Promise<void>;
+    addEntries(ids: string | string[], contents: string | string[], metadatas: Metadata | Metadata[], embeddings?: number[] | number[][]): Promise<void>;
+    updateEntries(ids: string | string[], contents: string | string[], metadatas: Metadata | Metadata[], embeddings?: number[] | number[][]): Promise<void>;
+    deleteEntries(ids: string | string[]): Promise<void>;
+    query(query: QueryParams): Promise<import("chromadb").QueryResponse>;
+    getEntries(ids: string | string[]): Promise<import("chromadb").GetResponse>;
+    getEntriesByMetadata(where: Metadata): Promise<import("chromadb").GetResponse>;
+    listCollections(): Promise<import("chromadb").CollectionType[]>;
+    deleteCollection(name: string): Promise<void>;
+    count(): Promise<number>;
+}
+export {};

package/dist/database/chromaClient.js

@@ -0,0 +1,109 @@
+import { ChromaClient as Chroma, Collection, QueryParams } from 'chromadb';
+export class IdaeChromaClient {
+    client;
+    collection = null;
+    collectionName;
+    constructor(config) {
+        try {
+            this.client = new Chroma(config);
+        }
+        catch (error) {
+            console.error('Erreur lors de la création du client Chroma:', error);
+            throw new Error('Impossible de se connecter à la base de données Chroma');
+        }
+    }
+    async initCollection(collectionName) {
+        if (!this.collection) {
+            try {
+                this.collectionName = collectionName;
+                this.collection = await this.client.getOrCreateCollection({
+                    name: this.collectionName
+                });
+            }
+            catch (error) {
+                console.error('Erreur lors de la création ou récupération de la collection:', error);
+                throw new Error(`Impossible de créer ou récupérer la collection ${this.collectionName}`);
+            }
+        }
+    }
+    async addEntries(ids, contents, metadatas, embeddings) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        await this.collection.add({
+            ids: Array.isArray(ids) ? ids : [ids],
+            documents: Array.isArray(contents) ? contents : [contents],
+            metadatas: Array.isArray(metadatas) ? metadatas : [metadatas],
+            embeddings: embeddings
+                ? Array.isArray(embeddings[0])
+                    ? embeddings
+                    : [embeddings]
+                : undefined
+        });
+    }
+    async updateEntries(ids, contents, metadatas, embeddings) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        await this.collection.update({
+            ids: Array.isArray(ids) ? ids : [ids],
+            documents: Array.isArray(contents) ? contents : [contents],
+            metadatas: Array.isArray(metadatas) ? metadatas : [metadatas],
+            embeddings: embeddings
+                ? Array.isArray(embeddings[0])
+                    ? embeddings
+                    : [embeddings]
+                : undefined
+        });
+    }
+    async deleteEntries(ids) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        await this.collection.delete({
+            ids: Array.isArray(ids) ? ids : [ids]
+        });
+    }
+    async query(query) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        return await this.collection.query(query);
+    }
+    async getEntries(ids) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        return await this.collection.get({
+            ids: Array.isArray(ids) ? ids : [ids]
+        });
+    }
+    async getEntriesByMetadata(where) {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        return await this.collection.get({
+            where
+        });
+    }
+    async listCollections() {
+        try {
+            return await this.client.listCollections();
+        }
+        catch (error) {
+            console.error('Erreur lors de la liste des collections:', error);
+            throw new Error('Impossible de lister les collections');
+        }
+    }
+    async deleteCollection(name) {
+        try {
+            await this.client.deleteCollection({ name });
+            if (this.collection?.name === name) {
+                this.collection = null;
+            }
+        }
+        catch (error) {
+            console.error('Erreur lors de la suppression de la collection:', error);
+            throw new Error(`Impossible de supprimer la collection ${name}`);
+        }
+    }
+    async count() {
+        if (!this.collection)
+            throw new Error('Collection not initialized');
+        return await this.collection.count();
+    }
+}

package/dist/engine/processor.d.ts

@@ -0,0 +1,8 @@
+import { IdaeChromaClient } from '../database/chromaClient.js';
+export declare class Processor {
+    private chromaClient;
+    constructor(chromaClient: IdaeChromaClient);
+    processFile(filePath: string, action: 'add' | 'change' | 'delete'): Promise<void>;
+    private generateFileId;
+    private getFileMetadata;
+}

package/dist/engine/processor.js

@@ -0,0 +1,36 @@
+import { IdaeChromaClient } from '../database/chromaClient.js';
+import fs from 'fs/promises';
+import path from 'path';
+export class Processor {
+    chromaClient;
+    constructor(chromaClient) {
+        this.chromaClient = chromaClient;
+    }
+    async processFile(filePath, action) {
+        const fileId = this.generateFileId(filePath);
+        const metadata = await this.getFileMetadata(filePath);
+        switch (action) {
+            case 'add':
+            case 'change': {
+                const content = await fs.readFile(filePath, 'utf-8');
+                await this.chromaClient.addEntries(fileId, content, metadata);
+                break;
+            }
+            case 'delete':
+                await this.chromaClient.deleteEntries(fileId);
+                break;
+        }
+    }
+    generateFileId(filePath) {
+        return path.relative(process.cwd(), filePath);
+    }
+    async getFileMetadata(filePath) {
+        const stats = await fs.stat(filePath);
+        return {
+            path: filePath,
+            size: stats.size,
+            lastModified: stats.mtime.toISOString(),
+            extension: path.extname(filePath)
+        };
+    }
+}

package/dist/engine/watcher.d.ts

@@ -0,0 +1,12 @@
+import { IdaeChromaClient } from '../database/chromaClient.js';
+import { WatcherOptions } from '../main.js';
+export declare class Watcher {
+    private directory;
+    private options;
+    private chromaClient;
+    private watcher;
+    private processor;
+    constructor(directory: string, options: WatcherOptions, chromaClient: IdaeChromaClient);
+    start(): void;
+    stop(): void;
+}

package/dist/engine/watcher.js

@@ -0,0 +1,27 @@
+import chokidar from 'chokidar';
+import { Processor } from './processor.js';
+import { IdaeChromaClient } from '../database/chromaClient.js';
+import { WatcherOptions } from '../main.js';
+export class Watcher {
+    directory;
+    options;
+    chromaClient;
+    watcher;
+    processor;
+    constructor(directory, options, chromaClient) {
+        this.directory = directory;
+        this.options = options;
+        this.chromaClient = chromaClient;
+        this.processor = new Processor(chromaClient);
+    }
+    start() {
+        this.watcher = chokidar.watch(this.directory, this.options);
+        this.watcher
+            .on('add', (path) => this.processor.processFile(path, 'add'))
+            .on('change', (path) => this.processor.processFile(path, 'change'))
+            .on('unlink', (path) => this.processor.processFile(path, 'delete'));
+    }
+    stop() {
+        this.watcher.close();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './main.js';
+export * from './engine/watcher.js';
+export * from './engine/processor.js';
+export * from './database/chromaClient.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+// auto exports of entry components
+export * from './main.js';
+export * from './engine/watcher.js';
+export * from './engine/processor.js';
+export * from './database/chromaClient.js';

package/dist/main.d.ts

@@ -0,0 +1,42 @@
+import { IdaeChromaClient } from './database/chromaClient.js';
+export interface ChromaDbConfig {
+    path: string;
+    collectionName?: string;
+}
+export interface WatcherOptions {
+    ignored?: string | RegExp | ((path: string) => boolean);
+    persistent?: boolean;
+    ignoreInitial?: boolean;
+    followSymlinks?: boolean;
+    cwd?: string;
+    disableGlobbing?: boolean;
+    usePolling?: boolean;
+    interval?: number;
+    binaryInterval?: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    awaitWriteFinish?: boolean | {
+        stabilityThreshold?: number;
+        pollInterval?: number;
+    };
+    ignorePermissionErrors?: boolean;
+    atomic?: boolean | number;
+}
+export interface SearchParams {
+    nResults?: number;
+    where?: Record<string, any>;
+    whereDocument?: Record<string, any>;
+}
+declare class IdaeChroma {
+    #private;
+    private watchers;
+    private configDir;
+    constructor(chromaDbConfig?: ChromaDbConfig);
+    get chromaClient(): IdaeChromaClient;
+    addWatcher(directory: string, options: WatcherOptions): Promise<void>;
+    searchEntries(query: string, params: SearchParams): Promise<any>;
+    stopAllWatchers(): void;
+    private saveWatcherConfig;
+    loadSavedWatchers(): Promise<void>;
+}
+export default IdaeChroma;

package/dist/main.js

@@ -0,0 +1,77 @@
+import { Watcher } from './engine/watcher.js';
+import { IdaeChromaClient } from './database/chromaClient.js';
+import fs from 'fs/promises';
+import path from 'path';
+class IdaeChroma {
+    watchers = new Map();
+    #chromaClient;
+    configDir;
+    constructor(chromaDbConfig) {
+        this.#chromaClient = new IdaeChromaClient(chromaDbConfig);
+        this.configDir = path.join(process.cwd(), 'config');
+    }
+    get chromaClient() {
+        return this.#chromaClient;
+    }
+    async addWatcher(directory, options) {
+        try {
+            const watcher = new Watcher(directory, options, this.#chromaClient);
+            this.watchers.set(directory, watcher);
+            watcher.start();
+            await this.saveWatcherConfig(directory, options);
+        }
+        catch (error) {
+            console.error(`Failed to add watcher for directory: ${directory}`, error);
+            throw error;
+        }
+    }
+    async searchEntries(query, params) {
+        try {
+            return await this.#chromaClient.query(query, params.nResults, params.where);
+        }
+        catch (error) {
+            console.error('Failed to search entries:', error);
+            throw error;
+        }
+    }
+    stopAllWatchers() {
+        this.watchers.forEach((watcher) => {
+            try {
+                watcher.stop();
+            }
+            catch (error) {
+                console.error(`Failed to stop watcher:`, error);
+            }
+        });
+    }
+    async saveWatcherConfig(directory, options) {
+        try {
+            const configName = `last_config_${path.basename(directory)}.json`;
+            const configPath = path.join(this.configDir, configName);
+            await fs.mkdir(this.configDir, { recursive: true });
+            await fs.writeFile(configPath, JSON.stringify({ directory, options }, null, 2));
+        }
+        catch (error) {
+            console.error(`Failed to save watcher config for directory: ${directory}`, error);
+            throw error;
+        }
+    }
+    async loadSavedWatchers() {
+        try {
+            const files = await fs.readdir(this.configDir);
+            for (const file of files) {
+                if (file.startsWith('last_config_') && file.endsWith('.json')) {
+                    const configPath = path.join(this.configDir, file);
+                    const configContent = await fs.readFile(configPath, 'utf-8');
+                    const { directory, options } = JSON.parse(configContent);
+                    await this.addWatcher(directory, options);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to load saved watchers:', error);
+            throw error;
+        }
+    }
+}
+export default IdaeChroma;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@medyll/idae-chroma",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run package",
+    "preview": "vite preview",
+    "package": "svelte-kit sync && svelte-package && publint",
+    "prepublishOnly": "npm run package",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "test": "vitest",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write .",
+    "package:pre": "node scripts/package-pre.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "peerDependencies": {
+    "svelte": "^5.0.0-next.1"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^3.0.0",
+    "@sveltejs/kit": "^2.0.0",
+    "@sveltejs/package": "^2.0.0",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0-next.6",
+    "@types/eslint": "^9.6.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-svelte": "^2.36.0",
+    "globals": "^15.0.0",
+    "prettier": "^3.1.1",
+    "prettier-plugin-svelte": "^3.1.2",
+    "publint": "^0.2.0",
+    "svelte": "^5.0.0-next.241",
+    "svelte-check": "^3.6.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vite": "^5.0.11",
+    "vitest": "^2.0.0"
+  },
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scope": "@medyll",
+  "dependencies": {
+    "chokidar": "^3.6.0",
+    "chromadb": "^1.8.1",
+    "chromadb-default-embed": "^2.13.2"
+  }
+}