modality-kit 0.5.8 → 0.6.1

package/dist/types/__tests__/util_text_compression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/util_text_compression.d.ts

@@ -0,0 +1,139 @@
+export interface CompressionConfig {
+    maxTokens: number;
+    compressionLevel: 'light' | 'moderate' | 'aggressive';
+    preserveCodeBlocks: boolean;
+    autoDetectLanguage: boolean;
+    enableLogging: boolean;
+    maxSentencesForAnalysis: number;
+    fastModeMaxSentences: number;
+}
+export declare const DEFAULT_CONFIG: CompressionConfig;
+export interface CompressionOptions {
+    maxTokens?: number;
+    compressionLevel?: 'light' | 'moderate' | 'aggressive';
+    preserveCodeBlocks?: boolean;
+    autoDetectLanguage?: boolean;
+    locale?: string;
+    prioritizeFirst?: boolean;
+    prioritizeLast?: boolean;
+    preserveStructure?: boolean;
+    bufferPercentage?: number;
+    maxSentences?: number;
+    fastMode?: boolean;
+    enableLogging?: boolean;
+    sentenceSplitPattern?: RegExp;
+    importanceWeights?: ImportanceWeights;
+    tokenizationMethod?: 'simple' | 'advanced';
+}
+export interface ImportanceWeights {
+    position: number;
+    length: number;
+    wordRarity: number;
+    codeElements: number;
+}
+export interface CompressionResult {
+    compressedText: string;
+    originalLength: number;
+    compressedLength: number;
+    compressionRatio: number;
+    tokensEstimate: number;
+    detectedLanguage?: string;
+    importanceScores?: Array<{
+        text: string;
+        score: number;
+        reasons: string[];
+    }>;
+    processingTime?: number;
+    errors?: string[];
+    warnings?: string[];
+}
+export interface LanguageDetectionResult {
+    code: string;
+    locale: string;
+    confidence: number;
+    script?: string;
+    region?: string;
+}
+export declare class CompressionError extends Error {
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, code: string, details?: any | undefined);
+}
+export declare class LanguageDetectionError extends Error {
+    fallbackLanguage: string;
+    constructor(message: string, fallbackLanguage: string);
+}
+export declare class CompressionLogger {
+    private enabled;
+    constructor(enabled?: boolean);
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: Error): void;
+}
+export declare class UniversalLanguageDetector {
+    private logger;
+    private cache;
+    constructor(logger: CompressionLogger);
+    detectLanguage(text: string): Promise<LanguageDetectionResult>;
+    private performDetection;
+    private analyzeUnicodeRanges;
+    private prioritizeLocalesBasedOnUnicode;
+    private getAvailableTestLocales;
+    private getUnicodeRelevanceScore;
+    private getUnicodeBoost;
+    private testLocaleWithIntlAPIs;
+    private enhanceWithTextAnalysis;
+    private detectFromTextHeuristics;
+}
+export declare class IntelligentImportanceAnalyzer {
+    private wordFrequencyCache;
+    private logger;
+    private config;
+    constructor(logger: CompressionLogger, config: CompressionConfig);
+    analyzeImportance(text: string, detectedLanguage?: string): Promise<Array<{
+        text: string;
+        score: number;
+        reasons: string[];
+    }>>;
+    fastAnalyzeImportance(text: string, detectedLanguage?: string): Promise<Array<{
+        text: string;
+        score: number;
+        reasons: string[];
+    }>>;
+    private segmentSentences;
+    private analyzePosition;
+    private analyzeLengthDeviation;
+    private analyzeWordRarity;
+    private calculateWordFrequencies;
+}
+export declare class TextCompressionUtility {
+    private languageDetector;
+    private importanceAnalyzer;
+    private logger;
+    private config;
+    constructor(config?: Partial<CompressionConfig>);
+    compress(text: string, options?: CompressionOptions): Promise<CompressionResult>;
+    private extractCodeElements;
+    private applyUserPriorities;
+    private applyCompression;
+    private getCompressionThreshold;
+    private segmentSentences;
+    private trimToTokenLimit;
+    private estimateTokens;
+}
+export declare function compressUserInput(text: string, maxTokens?: number): Promise<string>;
+export declare function compressConversationHistory(messages: Array<{
+    role: string;
+    content: string;
+}>, maxTokens: number): Promise<Array<{
+    role: string;
+    content: string;
+}>>;
+export declare function analyzeTextImportance(text: string): Promise<Array<{
+    text: string;
+    score: number;
+    reasons: string[];
+}>>;
+export declare function compressText(text: string, options?: CompressionOptions): Promise<CompressionResult>;
+export declare function fastCompressText(text: string, maxTokens?: number): Promise<string>;
+export declare function compressWithLanguageDetection(text: string, maxTokens?: number): Promise<CompressionResult>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.8",
+  "version": "0.6.1",
   "name": "modality-kit",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   "author": "Hill <hill@kimo.com>",
   "license": "ISC",
   "devDependencies": {
-    "@types/node": "^24.1.0",
+    "@types/bun": "^1.2.19",
     "fastmcp": "^3.12.0",
     "typescript": "^5.8.3",
     "zod": "3.x"
@@ -31,7 +31,7 @@
     "build:types": "bunx tsc -p ./",
     "build:src": "bun build src/index.ts --outdir dist",
     "build": "bun run build:clean && bun run build:src && bun run build:types",
-    "test": "npm run build",
+    "test": "bun test",
     "prepublishOnly": "npm run test"
   },
   "types": "./dist/types/index.d.ts",