devbrain-cli 0.2.0 → 0.3.0

package/node_modules/@devbrain/core/dist/index/VectorIndexer.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+export class VectorIndexer {
+    vectorStore;
+    embeddingProvider;
+    constructor(vectorStore, embeddingProvider) {
+        this.vectorStore = vectorStore;
+        this.embeddingProvider = embeddingProvider;
+    }
+    hashText(text) {
+        return crypto.createHash('sha256').update(text).digest('hex');
+    }
+    parseMarkdown(filePath, memoryId) {
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const chunks = [];
+        let currentSectionHeader = '';
+        let currentSectionLines = [];
+        const flushSection = (nextHeader) => {
+            // Clean header name (e.g., "## Authentication" -> "Authentication")
+            const headerTitle = currentSectionHeader.replace(/^#+\s+/, '').trim();
+            const NOISY_SECTIONS = [
+                'Folder Structure',
+                'Recent Changes',
+                'Repository Structure',
+                'Recent Commit Log',
+                'Git Metrics'
+            ];
+            if (NOISY_SECTIONS.includes(headerTitle)) {
+                currentSectionHeader = nextHeader;
+                currentSectionLines = [];
+                return;
+            }
+            if (currentSectionLines.length > 0 || headerTitle) {
+                const sectionText = [currentSectionHeader, ...currentSectionLines]
+                    .filter(Boolean)
+                    .join('\n')
+                    .trim();
+                const sectionId = this.hashText(`${memoryId}:section:${headerTitle || 'General'}`);
+                if (sectionText) {
+                    chunks.push({
+                        id: sectionId,
+                        memoryId,
+                        parentId: null,
+                        level: 'section',
+                        text: sectionText,
+                        textHash: this.hashText(sectionText),
+                        metadata: {
+                            title: headerTitle || 'General',
+                            filePath: memoryId
+                        }
+                    });
+                }
+                // Parse bullets and paragraphs inside the section
+                let bulletIdx = 0;
+                let currentParagraph = '';
+                const flushParagraph = () => {
+                    if (currentParagraph.trim()) {
+                        const bulletText = currentParagraph.trim();
+                        const bulletId = this.hashText(`${memoryId}:bullet:${sectionId}:${bulletIdx}:${bulletText}`);
+                        chunks.push({
+                            id: bulletId,
+                            memoryId,
+                            parentId: sectionId,
+                            level: 'bullet',
+                            text: bulletText,
+                            textHash: this.hashText(bulletText),
+                            metadata: {
+                                sectionTitle: headerTitle || 'General',
+                                filePath: memoryId,
+                                index: bulletIdx
+                            }
+                        });
+                        bulletIdx++;
+                        currentParagraph = '';
+                    }
+                };
+                for (const line of currentSectionLines) {
+                    const trimmed = line.trim();
+                    if (!trimmed) {
+                        flushParagraph();
+                        continue;
+                    }
+                    // Check if list item
+                    const listMatch = trimmed.match(/^([*\-+]|\d+\.)\s+(.*)/);
+                    if (listMatch) {
+                        flushParagraph();
+                        const bulletText = listMatch[2].trim();
+                        const bulletId = this.hashText(`${memoryId}:bullet:${sectionId}:${bulletIdx}:${bulletText}`);
+                        chunks.push({
+                            id: bulletId,
+                            memoryId,
+                            parentId: sectionId,
+                            level: 'bullet',
+                            text: trimmed,
+                            textHash: this.hashText(trimmed),
+                            metadata: {
+                                sectionTitle: headerTitle || 'General',
+                                filePath: memoryId,
+                                index: bulletIdx
+                            }
+                        });
+                        bulletIdx++;
+                    }
+                    else {
+                        currentParagraph += (currentParagraph ? ' ' : '') + trimmed;
+                    }
+                }
+                flushParagraph();
+            }
+            currentSectionHeader = nextHeader;
+            currentSectionLines = [];
+        };
+        for (const line of lines) {
+            if (line.startsWith('#')) {
+                flushSection(line.trim());
+            }
+            else {
+                currentSectionLines.push(line);
+            }
+        }
+        flushSection('');
+        return chunks;
+    }
+    async indexMemory(filePath, memoryId) {
+        this.vectorStore.initialize();
+        const parsedChunks = this.parseMarkdown(filePath, memoryId);
+        if (parsedChunks.length === 0)
+            return;
+        // Load existing database state for this file
+        const existing = await this.vectorStore.getAllChunksForMemory(memoryId);
+        const existingMap = new Map(existing.map(e => [e.id, e.textHash]));
+        const chunksToUpsert = [];
+        const activeIds = new Set();
+        for (const chunk of parsedChunks) {
+            activeIds.add(chunk.id);
+            const existingHash = existingMap.get(chunk.id);
+            if (existingHash === chunk.textHash) {
+                // Skip unchanged
+                continue;
+            }
+            chunksToUpsert.push(chunk);
+        }
+        // Embed new/changed chunks
+        if (chunksToUpsert.length > 0) {
+            const texts = chunksToUpsert.map(c => c.text);
+            const embeddings = await this.embeddingProvider.generateEmbeddings(texts);
+            for (let i = 0; i < chunksToUpsert.length; i++) {
+                chunksToUpsert[i].embedding = embeddings[i];
+                chunksToUpsert[i].metadata = JSON.stringify(chunksToUpsert[i].metadata);
+            }
+            await this.vectorStore.upsertChunks(chunksToUpsert);
+        }
+        // Delete stale chunks
+        const idsToDelete = [];
+        for (const { id } of existing) {
+            if (!activeIds.has(id)) {
+                idsToDelete.push(id);
+            }
+        }
+        if (idsToDelete.length > 0) {
+            await this.vectorStore.deleteChunks(idsToDelete);
+        }
+    }
+}
+//# sourceMappingURL=VectorIndexer.js.map

package/node_modules/@devbrain/core/dist/index/VectorStore.d.ts

@@ -0,0 +1,26 @@
+export interface VectorChunk {
+    id: string;
+    memoryId: string;
+    parentId: string | null;
+    level: 'section' | 'bullet';
+    text: string;
+    textHash: string;
+    embedding: number[];
+    metadata: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface VectorStore {
+    initialize(): void;
+    upsertChunks(chunks: VectorChunk[]): Promise<void>;
+    deleteChunks(ids: string[]): Promise<void>;
+    getChunksByHash(ids: string[]): Promise<Map<string, string>>;
+    getAllChunksForMemory(memoryId: string): Promise<{
+        id: string;
+        textHash: string;
+    }[]>;
+    search(queryEmbedding: number[]): Promise<VectorChunk[]>;
+    getChunkById(id: string): Promise<VectorChunk | null>;
+    clearAll(): Promise<void>;
+    close(): void;
+}

package/node_modules/@devbrain/core/dist/index/VectorStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VectorStore.js.map

package/node_modules/@devbrain/core/dist/index.d.ts

@@ -19,3 +19,11 @@ export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.a
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
 export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';
+export { EmbeddingProvider } from './embeddings/EmbeddingProvider.js';
+export { TransformersProvider } from './embeddings/TransformersProvider.js';
+export { VectorChunk, VectorStore } from './index/VectorStore.js';
+export { SQLiteVectorStore } from './index/SQLiteVectorStore.js';
+export { VectorIndexer } from './index/VectorIndexer.js';
+export { RankingEngine, GitCommitInfo } from './retrieval/RankingEngine.js';
+export { RetrievedMemory, SemanticRetriever } from './retrieval/SemanticRetriever.js';
+export { ContextBuilder } from './retrieval/ContextBuilder.js';

package/node_modules/@devbrain/core/dist/index.js

@@ -20,4 +20,10 @@ export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.a
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
 export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';
+export { TransformersProvider } from './embeddings/TransformersProvider.js';
+export { SQLiteVectorStore } from './index/SQLiteVectorStore.js';
+export { VectorIndexer } from './index/VectorIndexer.js';
+export { RankingEngine } from './retrieval/RankingEngine.js';
+export { SemanticRetriever } from './retrieval/SemanticRetriever.js';
+export { ContextBuilder } from './retrieval/ContextBuilder.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@devbrain/core/dist/retrieval/ContextBuilder.d.ts

@@ -0,0 +1,4 @@
+import { RetrievedMemory } from './SemanticRetriever.js';
+export declare class ContextBuilder {
+    buildContext(query: string, results: RetrievedMemory[]): string;
+}

package/node_modules/@devbrain/core/dist/retrieval/ContextBuilder.js

@@ -0,0 +1,107 @@
+export class ContextBuilder {
+    buildContext(query, results) {
+        if (results.length === 0) {
+            return [
+                '# DEVBRAIN AI CONTEXT (SEMANTIC SEARCH)',
+                '',
+                `Query: "${query}"`,
+                '',
+                'No matching local memories found.',
+            ].join('\n');
+        }
+        const lines = [];
+        lines.push('<!-- START OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        lines.push('# DEVBRAIN AI CONTEXT (SEMANTIC SEARCH)');
+        lines.push('');
+        lines.push(`Query: "${query}"`);
+        lines.push('');
+        lines.push('The following local memories were retrieved as highly relevant to your query:');
+        lines.push('');
+        const grouped = new Map();
+        const sectionsDirectlyMatched = [];
+        for (const res of results) {
+            const chunk = res.chunk;
+            if (chunk.level === 'section') {
+                sectionsDirectlyMatched.push(res);
+            }
+            else {
+                const parentId = chunk.parentId || 'orphan';
+                let parentTitle = 'General';
+                let parentText = '';
+                const memoryId = chunk.memoryId;
+                if (res.parentSection) {
+                    parentText = res.parentSection.text;
+                    try {
+                        const meta = JSON.parse(res.parentSection.metadata);
+                        parentTitle = meta.title || 'General';
+                    }
+                    catch { }
+                }
+                else {
+                    try {
+                        const meta = JSON.parse(chunk.metadata);
+                        parentTitle = meta.sectionTitle || 'General';
+                    }
+                    catch { }
+                }
+                const existing = grouped.get(parentId);
+                if (existing) {
+                    existing.maxScore = Math.max(existing.maxScore, res.score);
+                    if (!existing.bullets.includes(chunk.text)) {
+                        existing.bullets.push(chunk.text);
+                    }
+                }
+                else {
+                    grouped.set(parentId, {
+                        sectionTitle: parentTitle,
+                        memoryId,
+                        sectionText: parentText,
+                        maxScore: res.score,
+                        bullets: [chunk.text]
+                    });
+                }
+            }
+        }
+        if (sectionsDirectlyMatched.length > 0) {
+            lines.push('## SECTION LEVEL MATCHES');
+            lines.push('');
+            for (const sec of sectionsDirectlyMatched) {
+                let title = 'General';
+                try {
+                    const meta = JSON.parse(sec.chunk.metadata);
+                    title = meta.title || 'General';
+                }
+                catch { }
+                lines.push(`### Section: ${title} (Score: ${sec.score})`);
+                lines.push(`Source: \`${sec.chunk.memoryId}\``);
+                lines.push('');
+                lines.push(sec.chunk.text);
+                lines.push('');
+            }
+        }
+        if (grouped.size > 0) {
+            lines.push('## DETAILED CONTEXT MATCHES');
+            lines.push('');
+            for (const [_, val] of grouped.entries()) {
+                lines.push(`### Section: ${val.sectionTitle} (Max Bullet Score: ${val.maxScore})`);
+                lines.push(`Source: \`${val.memoryId}\``);
+                lines.push('');
+                if (val.sectionText) {
+                    lines.push('#### Expanded Context:');
+                    lines.push('```markdown');
+                    lines.push(val.sectionText);
+                    lines.push('```');
+                    lines.push('');
+                }
+                lines.push('#### Exact Semantic Matches:');
+                for (const bullet of val.bullets) {
+                    lines.push(`- ${bullet}`);
+                }
+                lines.push('');
+            }
+        }
+        lines.push('<!-- END OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=ContextBuilder.js.map

package/node_modules/@devbrain/core/dist/retrieval/RankingEngine.d.ts

@@ -0,0 +1,13 @@
+import { DevBrainConfig } from '@devbrain/shared';
+import { VectorChunk } from '../index/VectorStore.js';
+export interface GitCommitInfo {
+    hash: string;
+    message: string;
+}
+export declare const CATEGORY_WEIGHTS: Record<string, number>;
+export declare class RankingEngine {
+    private config;
+    constructor(config: DevBrainConfig);
+    getCategory(chunk: VectorChunk): string;
+    calculateScore(chunk: VectorChunk, recentCommits?: GitCommitInfo[]): number;
+}

package/node_modules/@devbrain/core/dist/retrieval/RankingEngine.js

@@ -0,0 +1,124 @@
+export const CATEGORY_WEIGHTS = {
+    authentication: 1.25,
+    architecture: 1.20,
+    database: 1.15,
+    api: 1.20,
+    deployment: 1.10,
+    features: 1.05,
+    rules: 1.05,
+    techstack: 1.05,
+    patterns: 1.10,
+    workflows: 1.05,
+    general: 1.00,
+    metadata: 0.30
+};
+export class RankingEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getCategory(chunk) {
+        let meta = {};
+        try {
+            meta = JSON.parse(chunk.metadata);
+        }
+        catch { }
+        const title = (meta.sectionTitle || meta.title || 'General').toLowerCase();
+        const filePath = (meta.filePath || '').toLowerCase();
+        if (title.includes('folder structure') ||
+            title.includes('repository structure') ||
+            title.includes('recent changes') ||
+            title.includes('commit log') ||
+            title.includes('git metrics') ||
+            filePath.includes('timeline.md') ||
+            title.includes('file inventory')) {
+            return 'metadata';
+        }
+        if (title.includes('auth') || title.includes('login') || title.includes('security') || title.includes('session') || title.includes('oauth') || title.includes('jwt')) {
+            return 'authentication';
+        }
+        if (title.includes('arch') || title.includes('structure') || title.includes('design') || filePath.includes('architecture.md')) {
+            return 'architecture';
+        }
+        if (title.includes('database') || title.includes('db') || title.includes('model') || title.includes('schema') || title.includes('entity')) {
+            return 'database';
+        }
+        if (title.includes('api') || title.includes('route') || title.includes('endpoint') || title.includes('http') || title.includes('controller')) {
+            return 'api';
+        }
+        if (title.includes('deploy') || title.includes('docker') || title.includes('ci') || title.includes('cd') || title.includes('github actions')) {
+            return 'deployment';
+        }
+        if (title.includes('feature') || title.includes('product') || filePath.includes('features.md')) {
+            return 'features';
+        }
+        if (title.includes('rule') || title.includes('convention') || title.includes('standard') || title.includes('style') || filePath.includes('rules.md')) {
+            return 'rules';
+        }
+        if (title.includes('stack') || title.includes('tech') || title.includes('package') || filePath.includes('stack.md')) {
+            return 'techstack';
+        }
+        if (title.includes('pattern') || title.includes('practice')) {
+            return 'patterns';
+        }
+        if (title.includes('workflow') || title.includes('lifecycle')) {
+            return 'workflows';
+        }
+        return 'general';
+    }
+    calculateScore(chunk, recentCommits = []) {
+        const searchConfig = this.config.semanticSearch || {};
+        const configBoosts = searchConfig.boosts || {};
+        // 1. Base Semantic similarity
+        let meta = {};
+        try {
+            meta = JSON.parse(chunk.metadata);
+        }
+        catch { }
+        const similarity = meta.similarity !== undefined ? meta.similarity : 0.0;
+        const baseScore = Math.max(0.001, similarity);
+        // 2. Category Weight
+        const category = this.getCategory(chunk);
+        let categoryWeight = CATEGORY_WEIGHTS[category] ?? 1.00;
+        if (configBoosts[category] !== undefined && typeof configBoosts[category] === 'number') {
+            categoryWeight = configBoosts[category];
+        }
+        // 3. Importance Boost
+        let importanceMultiplier = 1.0;
+        if (meta.importance && typeof meta.importance === 'number') {
+            importanceMultiplier = meta.importance;
+        }
+        // 4. Pinned Boost
+        let pinMultiplier = 1.0;
+        if (meta.pinned === true || meta.pinned === 'true') {
+            pinMultiplier = configBoosts['pinned'] ?? 1.8;
+        }
+        // 5. Git Relevance Boost
+        let gitFrequencyMultiplier = 1.0;
+        if (recentCommits.length > 0) {
+            const sectionTitle = (meta.sectionTitle || meta.title || 'General').toLowerCase();
+            const words = sectionTitle.split(/\s+/).filter((w) => w.length > 3);
+            if (words.length > 0) {
+                let matchCount = 0;
+                for (const commit of recentCommits) {
+                    const msg = commit.message.toLowerCase();
+                    if (words.some((word) => msg.includes(word))) {
+                        matchCount++;
+                    }
+                }
+                const ratio = matchCount / recentCommits.length;
+                const maxGitBoost = 0.25;
+                gitFrequencyMultiplier = 1.0 + (ratio * maxGitBoost);
+            }
+        }
+        // 6. Recency Boost
+        let recencyMultiplier = 1.0;
+        if (meta.recent === true) {
+            recencyMultiplier = 1.15;
+        }
+        // Multiplicative composite score
+        const finalScore = baseScore * categoryWeight * importanceMultiplier * pinMultiplier * gitFrequencyMultiplier * recencyMultiplier;
+        return parseFloat(finalScore.toFixed(6));
+    }
+}
+//# sourceMappingURL=RankingEngine.js.map

package/node_modules/@devbrain/core/dist/retrieval/SemanticRetriever.d.ts

@@ -0,0 +1,17 @@
+import { VectorStore, VectorChunk } from '../index/VectorStore.js';
+import { EmbeddingProvider } from '../embeddings/EmbeddingProvider.js';
+import { RankingEngine, GitCommitInfo } from './RankingEngine.js';
+import { DevBrainConfig } from '@devbrain/shared';
+export interface RetrievedMemory {
+    chunk: VectorChunk;
+    score: number;
+    parentSection: VectorChunk | null;
+}
+export declare class SemanticRetriever {
+    private readonly vectorStore;
+    private readonly embeddingProvider;
+    private readonly rankingEngine;
+    private readonly config?;
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, rankingEngine: RankingEngine, config?: DevBrainConfig | undefined);
+    searchRelevantMemories(query: string, topK?: number, recentCommits?: GitCommitInfo[]): Promise<RetrievedMemory[]>;
+}

package/node_modules/@devbrain/core/dist/retrieval/SemanticRetriever.js

@@ -0,0 +1,48 @@
+export class SemanticRetriever {
+    vectorStore;
+    embeddingProvider;
+    rankingEngine;
+    config;
+    constructor(vectorStore, embeddingProvider, rankingEngine, config) {
+        this.vectorStore = vectorStore;
+        this.embeddingProvider = embeddingProvider;
+        this.rankingEngine = rankingEngine;
+        this.config = config;
+    }
+    async searchRelevantMemories(query, topK = 8, recentCommits = []) {
+        this.vectorStore.initialize();
+        // 1. Generate query embedding
+        const queryEmbedding = await this.embeddingProvider.generateEmbedding(query);
+        // 2. Perform cosine similarity search
+        const matches = await this.vectorStore.search(queryEmbedding);
+        // 3. Filter by minSimilarity and compute composite score rankings
+        const minSimilarity = this.config?.semanticSearch?.minSimilarity ?? 0.30;
+        const scoredMatches = [];
+        for (const chunk of matches) {
+            let meta = {};
+            try {
+                meta = JSON.parse(chunk.metadata);
+            }
+            catch { }
+            const similarity = meta.similarity !== undefined ? meta.similarity : 0.0;
+            if (similarity < minSimilarity) {
+                continue;
+            }
+            const score = this.rankingEngine.calculateScore(chunk, recentCommits);
+            let parentSection = null;
+            if (chunk.level === 'bullet' && chunk.parentId) {
+                parentSection = await this.vectorStore.getChunkById(chunk.parentId);
+            }
+            scoredMatches.push({
+                chunk,
+                score,
+                parentSection
+            });
+        }
+        // 4. Sort by the calculated final ranking score
+        scoredMatches.sort((a, b) => b.score - a.score);
+        // 5. Return topK results
+        return scoredMatches.slice(0, topK);
+    }
+}
+//# sourceMappingURL=SemanticRetriever.js.map

package/node_modules/@devbrain/core/package.json

@@ -1,22 +1,23 @@
-{
-  "name": "@devbrain/core",
-  "version": "0.2.0",
-  "private": true,
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "tsc --build"
-  },
-  "dependencies": {
-    "@devbrain/shared": "^0.2.0"
-  },
-  "devDependencies": {
-    "fast-glob": "^3.3.2",
-    "fast-xml-parser": "^5.9.3",
-    "simple-git": "^3.23.0"
-  }
-}
+{
+  "name": "@devbrain/core",
+  "version": "0.3.0",
+  "private": true,
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build"
+  },
+  "dependencies": {
+    "@devbrain/shared": "^0.3.0",
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "devDependencies": {
+    "fast-glob": "^3.3.2",
+    "fast-xml-parser": "^5.9.3",
+    "simple-git": "^3.23.0"
+  }
+}

package/node_modules/@devbrain/shared/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const DEVBRAIN_VERSION = "0.2.0";
+export declare const DEVBRAIN_VERSION = "0.3.0";
 export declare const DEFAULT_IGNORE_PATTERNS: string[];
 export declare const CONFIG_FILE_NAME = "config.json";
 export declare const DEVBRAIN_DIR_NAME = ".devbrain";

package/node_modules/@devbrain/shared/dist/constants.js

@@ -1,4 +1,4 @@
-export const DEVBRAIN_VERSION = '0.2.0';
+export const DEVBRAIN_VERSION = '0.3.0';
 export const DEFAULT_IGNORE_PATTERNS = [
     '**/node_modules/**',
     '**/.git/**',

package/node_modules/@devbrain/shared/dist/types.d.ts

@@ -26,6 +26,17 @@ export interface DevBrainConfig {
     context_generation?: boolean;
     verbose_logging?: boolean;
     safe_mode?: boolean;
+    semanticSearch?: {
+        topK?: number;
+        minSimilarity?: number;
+        weights?: {
+            semantic?: number;
+            recency?: number;
+            importance?: number;
+            gitFrequency?: number;
+        };
+        boosts?: Record<string, number>;
+    };
 }
 /**
  * Entry schema for commits history tracking.

package/node_modules/@devbrain/shared/package.json

@@ -1,14 +1,14 @@
-{
-  "name": "@devbrain/shared",
-  "version": "0.2.0",
-  "private": true,
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "tsc --build"
-  }
-}
+{
+  "name": "@devbrain/shared",
+  "version": "0.3.0",
+  "private": true,
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build"
+  }
+}