@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/client.js

@@ -0,0 +1,251 @@
+import { embeddingService } from "./embedding.js";
+import { shardManager } from "./sqlite/shard-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+function safeToISOString(timestamp) {
+    try {
+        if (timestamp === null || timestamp === undefined) {
+            return new Date().toISOString();
+        }
+        const numValue = typeof timestamp === "bigint" ? Number(timestamp) : Number(timestamp);
+        if (isNaN(numValue) || numValue < 0) {
+            return new Date().toISOString();
+        }
+        return new Date(numValue).toISOString();
+    }
+    catch {
+        return new Date().toISOString();
+    }
+}
+function safeJSONParse(jsonString) {
+    if (!jsonString || typeof jsonString !== "string") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractScopeFromContainerTag(containerTag) {
+    const parts = containerTag.split("_");
+    if (parts.length >= 3) {
+        const scope = parts[1];
+        const hash = parts.slice(2).join("_");
+        return { scope, hash };
+    }
+    return { scope: "user", hash: containerTag };
+}
+export class LocalMemoryClient {
+    initPromise = null;
+    isInitialized = false;
+    constructor() { }
+    async initialize() {
+        if (this.isInitialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            try {
+                this.isInitialized = true;
+            }
+            catch (error) {
+                this.initPromise = null;
+                log("SQLite initialization failed", { error: String(error) });
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    async warmup(progressCallback) {
+        await this.initialize();
+        await embeddingService.warmup(progressCallback);
+    }
+    async isReady() {
+        return this.isInitialized && embeddingService.isWarmedUp;
+    }
+    getStatus() {
+        return {
+            dbConnected: this.isInitialized,
+            modelLoaded: embeddingService.isWarmedUp,
+            ready: this.isInitialized && embeddingService.isWarmedUp,
+        };
+    }
+    close() {
+        connectionManager.closeAll();
+    }
+    async searchMemories(query, containerTag) {
+        try {
+            await this.initialize();
+            const queryVector = await embeddingService.embedWithTimeout(query);
+            const { scope, hash } = extractScopeFromContainerTag(containerTag);
+            const shards = shardManager.getAllShards(scope, hash);
+            if (shards.length === 0) {
+                return { success: true, results: [], total: 0, timing: 0 };
+            }
+            const results = await vectorSearch.searchAcrossShards(shards, queryVector, containerTag, CONFIG.maxMemories, CONFIG.similarityThreshold, query);
+            return { success: true, results, total: results.length, timing: 0 };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("searchMemories: error", { error: errorMessage });
+            return { success: false, error: errorMessage, results: [], total: 0, timing: 0 };
+        }
+    }
+    async addMemory(content, containerTag, metadata) {
+        try {
+            await this.initialize();
+            const tags = metadata?.tags || [];
+            const vector = await embeddingService.embedWithTimeout(content);
+            let tagsVector = undefined;
+            if (tags.length > 0) {
+                tagsVector = await embeddingService.embedWithTimeout(tags.join(", "));
+            }
+            const { scope, hash } = extractScopeFromContainerTag(containerTag);
+            const shard = shardManager.getWriteShard(scope, hash);
+            const id = `mem_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+            const now = Date.now();
+            const { displayName, userName, userEmail, projectPath, projectName, gitRepoUrl, type, tags: _tags, ...dynamicMetadata } = metadata || {};
+            const record = {
+                id,
+                content,
+                vector,
+                tagsVector,
+                containerTag,
+                tags: tags.length > 0 ? tags.join(",") : undefined,
+                type,
+                createdAt: now,
+                updatedAt: now,
+                displayName,
+                userName,
+                userEmail,
+                projectPath,
+                projectName,
+                gitRepoUrl,
+                metadata: Object.keys(dynamicMetadata).length > 0 ? JSON.stringify(dynamicMetadata) : undefined,
+            };
+            const db = connectionManager.getConnection(shard.dbPath);
+            await vectorSearch.insertVector(db, record, shard);
+            shardManager.incrementVectorCount(shard.id);
+            return { success: true, id };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("addMemory: error", { error: errorMessage });
+            return { success: false, error: errorMessage };
+        }
+    }
+    async deleteMemory(memoryId) {
+        try {
+            await this.initialize();
+            const userShards = shardManager.getAllShards("user", "");
+            const projectShards = shardManager.getAllShards("project", "");
+            const allShards = [...userShards, ...projectShards];
+            for (const shard of allShards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const memory = vectorSearch.getMemoryById(db, memoryId);
+                if (memory) {
+                    await vectorSearch.deleteVector(db, memoryId, shard);
+                    shardManager.decrementVectorCount(shard.id);
+                    return { success: true };
+                }
+            }
+            return { success: false, error: "Memory not found" };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("deleteMemory: error", { memoryId, error: errorMessage });
+            return { success: false, error: errorMessage };
+        }
+    }
+    async listMemories(containerTag, limit = 20) {
+        try {
+            await this.initialize();
+            const { scope, hash } = extractScopeFromContainerTag(containerTag);
+            const shards = shardManager.getAllShards(scope, hash);
+            if (shards.length === 0) {
+                return {
+                    success: true,
+                    memories: [],
+                    pagination: { currentPage: 1, totalItems: 0, totalPages: 0 },
+                };
+            }
+            const allMemories = [];
+            for (const shard of shards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const memories = vectorSearch.listMemories(db, containerTag, limit);
+                allMemories.push(...memories);
+            }
+            allMemories.sort((a, b) => Number(b.created_at) - Number(a.created_at));
+            const memories = allMemories.slice(0, limit).map((r) => ({
+                id: r.id,
+                summary: r.content,
+                createdAt: safeToISOString(r.created_at),
+                metadata: safeJSONParse(r.metadata),
+                displayName: r.display_name,
+                userName: r.user_name,
+                userEmail: r.user_email,
+                projectPath: r.project_path,
+                projectName: r.project_name,
+                gitRepoUrl: r.git_repo_url,
+            }));
+            return {
+                success: true,
+                memories,
+                pagination: { currentPage: 1, totalItems: memories.length, totalPages: 1 },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("listMemories: error", { error: errorMessage });
+            return {
+                success: false,
+                error: errorMessage,
+                memories: [],
+                pagination: { currentPage: 1, totalItems: 0, totalPages: 0 },
+            };
+        }
+    }
+    async searchMemoriesBySessionID(sessionID, containerTag, limit = 10) {
+        try {
+            await this.initialize();
+            const { scope, hash } = extractScopeFromContainerTag(containerTag);
+            const shards = shardManager.getAllShards(scope, hash);
+            if (shards.length === 0) {
+                return { success: true, results: [], total: 0, timing: 0 };
+            }
+            const allMemories = [];
+            for (const shard of shards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const memories = vectorSearch.getMemoriesBySessionID(db, sessionID);
+                allMemories.push(...memories);
+            }
+            allMemories.sort((a, b) => b.created_at - a.created_at);
+            const results = allMemories.slice(0, limit).map((row) => ({
+                id: row.id,
+                memory: row.content,
+                similarity: 1.0,
+                tags: row.tags || [],
+                metadata: row.metadata || {},
+                containerTag: row.container_tag,
+                displayName: row.display_name,
+                userName: row.user_name,
+                userEmail: row.user_email,
+                projectPath: row.project_path,
+                projectName: row.project_name,
+                gitRepoUrl: row.git_repo_url,
+                createdAt: row.created_at,
+            }));
+            return { success: true, results, total: results.length, timing: 0 };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log("searchMemoriesBySessionID: error", { error: errorMessage });
+            return { success: false, error: errorMessage, results: [], total: 0, timing: 0 };
+        }
+    }
+}
+export const memoryClient = new LocalMemoryClient();

package/dist/services/context.d.ts

@@ -0,0 +1,11 @@
+interface MemoryResultMinimal {
+    similarity: number;
+    memory?: string;
+    chunk?: string;
+}
+interface MemoriesResponseMinimal {
+    results?: MemoryResultMinimal[];
+}
+export declare function formatContextForPrompt(userId: string | null, projectMemories: MemoriesResponseMinimal): string;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/services/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/services/context.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,eAAe,EAAE,uBAAuB,GACvC,MAAM,CAyBR"}

package/dist/services/context.js

@@ -0,0 +1,24 @@
+import { CONFIG } from "../config.js";
+import { getUserProfileContext } from "./user-profile/profile-context.js";
+export function formatContextForPrompt(userId, projectMemories) {
+    const parts = ["[MEMORY]"];
+    if (CONFIG.injectProfile && userId) {
+        const profileContext = getUserProfileContext(userId);
+        if (profileContext) {
+            parts.push("\n" + profileContext);
+        }
+    }
+    const projectResults = projectMemories.results || [];
+    if (projectResults.length > 0) {
+        parts.push("\nProject Knowledge:");
+        projectResults.forEach((mem) => {
+            const similarity = Math.round(mem.similarity * 100);
+            const content = mem.memory || mem.chunk || "";
+            parts.push(`- [${similarity}%] ${content}`);
+        });
+    }
+    if (parts.length === 1) {
+        return "";
+    }
+    return parts.join("\n");
+}

package/dist/services/deduplication-service.d.ts

@@ -0,0 +1,30 @@
+interface DuplicateGroup {
+    representative: {
+        id: string;
+        content: string;
+        containerTag: string;
+        createdAt: number;
+    };
+    duplicates: Array<{
+        id: string;
+        content: string;
+        similarity: number;
+    }>;
+}
+interface DeduplicationResult {
+    exactDuplicatesDeleted: number;
+    nearDuplicateGroups: DuplicateGroup[];
+}
+export declare class DeduplicationService {
+    private isRunning;
+    detectAndRemoveDuplicates(): Promise<DeduplicationResult>;
+    private cosineSimilarity;
+    getStatus(): {
+        enabled: boolean;
+        threshold: number;
+        isRunning: boolean;
+    };
+}
+export declare const deduplicationService: DeduplicationService;
+export {};
+//# sourceMappingURL=deduplication-service.d.ts.map

package/dist/services/deduplication-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplication-service.d.ts","sourceRoot":"","sources":["../../src/services/deduplication-service.ts"],"names":[],"mappings":"AAMA,UAAU,cAAc;IACtB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAED,UAAU,mBAAmB;IAC3B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,cAAc,EAAE,CAAC;CACvC;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,SAAS,CAAkB;IAE7B,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAwG/D,OAAO,CAAC,gBAAgB;IAoBxB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/dist/services/deduplication-service.js

@@ -0,0 +1,124 @@
+import { shardManager } from "./sqlite/shard-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+export class DeduplicationService {
+    isRunning = false;
+    async detectAndRemoveDuplicates() {
+        if (this.isRunning) {
+            throw new Error("Deduplication already running");
+        }
+        if (!CONFIG.deduplicationEnabled) {
+            throw new Error("Deduplication is disabled in config");
+        }
+        this.isRunning = true;
+        try {
+            const userShards = shardManager.getAllShards("user", "");
+            const projectShards = shardManager.getAllShards("project", "");
+            const allShards = [...userShards, ...projectShards];
+            let exactDeleted = 0;
+            const nearDuplicateGroups = [];
+            for (const shard of allShards) {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const memories = vectorSearch.getAllMemories(db);
+                const contentMap = new Map();
+                for (const memory of memories) {
+                    const key = `${memory.container_tag}:${memory.content}`;
+                    if (!contentMap.has(key)) {
+                        contentMap.set(key, []);
+                    }
+                    contentMap.get(key).push(memory);
+                }
+                for (const [, duplicates] of contentMap) {
+                    if (duplicates.length > 1) {
+                        duplicates.sort((a, b) => Number(b.created_at) - Number(a.created_at));
+                        const toDelete = duplicates.slice(1);
+                        for (const dup of toDelete) {
+                            try {
+                                await vectorSearch.deleteVector(db, dup.id, shard);
+                                shardManager.decrementVectorCount(shard.id);
+                                exactDeleted++;
+                            }
+                            catch (error) {
+                                log("Deduplication: delete error", {
+                                    memoryId: dup.id,
+                                    error: String(error),
+                                });
+                            }
+                        }
+                    }
+                }
+                const uniqueMemories = Array.from(contentMap.values()).map((arr) => arr[0]);
+                const processedIds = new Set();
+                for (let i = 0; i < uniqueMemories.length; i++) {
+                    const mem1 = uniqueMemories[i];
+                    if (!mem1.vector || processedIds.has(mem1.id))
+                        continue;
+                    const vector1 = new Float32Array(new Uint8Array(mem1.vector).buffer);
+                    const similarGroup = {
+                        representative: {
+                            id: mem1.id,
+                            content: mem1.content,
+                            containerTag: mem1.container_tag,
+                            createdAt: mem1.created_at,
+                        },
+                        duplicates: [],
+                    };
+                    for (let j = i + 1; j < uniqueMemories.length; j++) {
+                        const mem2 = uniqueMemories[j];
+                        if (!mem2.vector || processedIds.has(mem2.id))
+                            continue;
+                        if (mem1.container_tag !== mem2.container_tag)
+                            continue;
+                        const vector2 = new Float32Array(new Uint8Array(mem2.vector).buffer);
+                        const similarity = this.cosineSimilarity(vector1, vector2);
+                        if (similarity >= CONFIG.deduplicationSimilarityThreshold && similarity < 1.0) {
+                            similarGroup.duplicates.push({
+                                id: mem2.id,
+                                content: mem2.content,
+                                similarity,
+                            });
+                            processedIds.add(mem2.id);
+                        }
+                    }
+                    if (similarGroup.duplicates.length > 0) {
+                        nearDuplicateGroups.push(similarGroup);
+                    }
+                }
+            }
+            return {
+                exactDuplicatesDeleted: exactDeleted,
+                nearDuplicateGroups,
+            };
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const aVal = a[i] || 0;
+            const bVal = b[i] || 0;
+            dotProduct += aVal * bVal;
+            normA += aVal * aVal;
+            normB += bVal * bVal;
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    getStatus() {
+        return {
+            enabled: CONFIG.deduplicationEnabled,
+            threshold: CONFIG.deduplicationSimilarityThreshold,
+            isRunning: this.isRunning,
+        };
+    }
+}
+export const deduplicationService = new DeduplicationService();

package/dist/services/embedding.d.ts

@@ -0,0 +1,15 @@
+export declare class EmbeddingService {
+    private pipe;
+    private initPromise;
+    isWarmedUp: boolean;
+    private cache;
+    private cachedModelName;
+    static getInstance(): EmbeddingService;
+    warmup(progressCallback?: (progress: any) => void): Promise<void>;
+    private initializeModel;
+    embed(text: string): Promise<Float32Array>;
+    embedWithTimeout(text: string): Promise<Float32Array>;
+    clearCache(): void;
+}
+export declare const embeddingService: EmbeddingService;
+//# sourceMappingURL=embedding.d.ts.map

package/dist/services/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/services/embedding.ts"],"names":[],"mappings":"AAoBA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,WAAW,CAA8B;IAC1C,UAAU,EAAE,OAAO,CAAS;IACnC,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,eAAe,CAAuB;IAE9C,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAOhC,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YAOzD,eAAe;IAiBvB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAmD1C,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI3D,UAAU,IAAI,IAAI;CAGnB;AAED,eAAO,MAAM,gBAAgB,kBAAiC,CAAC"}

package/dist/services/embedding.js

@@ -0,0 +1,106 @@
+import { pipeline, env } from "@xenova/transformers";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+import { join } from "node:path";
+env.allowLocalModels = true;
+env.allowRemoteModels = true;
+env.cacheDir = join(CONFIG.storagePath, ".cache");
+const TIMEOUT_MS = 30000;
+const GLOBAL_EMBEDDING_KEY = Symbol.for("opencode-mem.embedding.instance");
+const MAX_CACHE_SIZE = 100;
+function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms)),
+    ]);
+}
+export class EmbeddingService {
+    pipe = null;
+    initPromise = null;
+    isWarmedUp = false;
+    cache = new Map();
+    cachedModelName = null;
+    static getInstance() {
+        if (!globalThis[GLOBAL_EMBEDDING_KEY]) {
+            globalThis[GLOBAL_EMBEDDING_KEY] = new EmbeddingService();
+        }
+        return globalThis[GLOBAL_EMBEDDING_KEY];
+    }
+    async warmup(progressCallback) {
+        if (this.isWarmedUp)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.initializeModel(progressCallback);
+        return this.initPromise;
+    }
+    async initializeModel(progressCallback) {
+        try {
+            if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
+                this.isWarmedUp = true;
+                return;
+            }
+            this.pipe = await pipeline("feature-extraction", CONFIG.embeddingModel, {
+                progress_callback: progressCallback,
+            });
+            this.isWarmedUp = true;
+        }
+        catch (error) {
+            this.initPromise = null;
+            log("Failed to initialize embedding model", { error: String(error) });
+            throw error;
+        }
+    }
+    async embed(text) {
+        if (this.cachedModelName !== CONFIG.embeddingModel) {
+            this.clearCache();
+            this.cachedModelName = CONFIG.embeddingModel;
+        }
+        const cached = this.cache.get(text);
+        if (cached)
+            return cached;
+        if (!this.isWarmedUp && !this.initPromise) {
+            await this.warmup();
+        }
+        if (this.initPromise) {
+            await this.initPromise;
+        }
+        let result;
+        if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
+            const response = await fetch(`${CONFIG.embeddingApiUrl}/embeddings`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${CONFIG.embeddingApiKey}`,
+                },
+                body: JSON.stringify({
+                    input: text,
+                    model: CONFIG.embeddingModel,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`API embedding failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            result = new Float32Array(data.data[0].embedding);
+        }
+        else {
+            const output = await this.pipe(text, { pooling: "mean", normalize: true });
+            result = new Float32Array(output.data);
+        }
+        if (this.cache.size >= MAX_CACHE_SIZE) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(text, result);
+        return result;
+    }
+    async embedWithTimeout(text) {
+        return withTimeout(this.embed(text), TIMEOUT_MS);
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+export const embeddingService = EmbeddingService.getInstance();

package/dist/services/jsonc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Strips comments from JSONC content while respecting string boundaries.
+ * Handles // and /* comments, URLs in strings, and escaped quotes.
+ * Also removes trailing commas to support more relaxed JSONC format.
+ */
+export declare function stripJsoncComments(content: string): string;
+//# sourceMappingURL=jsonc.d.ts.map

package/dist/services/jsonc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonc.d.ts","sourceRoot":"","sources":["../../src/services/jsonc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA+E1D"}

package/dist/services/jsonc.js

@@ -0,0 +1,76 @@
+/**
+ * Strips comments from JSONC content while respecting string boundaries.
+ * Handles // and /* comments, URLs in strings, and escaped quotes.
+ * Also removes trailing commas to support more relaxed JSONC format.
+ */
+export function stripJsoncComments(content) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let inSingleLineComment = false;
+    let inMultiLineComment = false;
+    while (i < content.length) {
+        const char = content[i];
+        const nextChar = content[i + 1];
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === '"') {
+                // Count consecutive backslashes before this quote
+                let backslashCount = 0;
+                let j = i - 1;
+                while (j >= 0 && content[j] === "\\") {
+                    backslashCount++;
+                    j--;
+                }
+                // Quote is escaped only if preceded by ODD number of backslashes
+                // e.g., \" = escaped, \\" = not escaped (escaped backslash + quote)
+                if (backslashCount % 2 === 0) {
+                    inString = !inString;
+                }
+                result += char;
+                i++;
+                continue;
+            }
+        }
+        if (inString) {
+            result += char;
+            i++;
+            continue;
+        }
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === "/" && nextChar === "/") {
+                inSingleLineComment = true;
+                i += 2;
+                continue;
+            }
+            if (char === "/" && nextChar === "*") {
+                inMultiLineComment = true;
+                i += 2;
+                continue;
+            }
+        }
+        if (inSingleLineComment) {
+            if (char === "\n") {
+                inSingleLineComment = false;
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        if (inMultiLineComment) {
+            if (char === "*" && nextChar === "/") {
+                inMultiLineComment = false;
+                i += 2;
+                continue;
+            }
+            if (char === "\n") {
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        result += char;
+        i++;
+    }
+    // Remove trailing commas before } or ]
+    return result.replace(/,\s*([}\]])/g, "$1");
+}

package/dist/services/language-detector.d.ts

@@ -0,0 +1,3 @@
+export declare function detectLanguage(text: string): string;
+export declare function getLanguageName(code: string): string;
+//# sourceMappingURL=language-detector.d.ts.map

package/dist/services/language-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../src/services/language-detector.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYnD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpD"}