modality-kit 0.5.7 → 0.6.0

package/dist/index.js

@@ -105,7 +105,7 @@ class ModalityLogger {
   setLogLevel(level) {
     this.logLevel = level;
   }
-  format(level, payload, categroy) {
+  format(level, categroy) {
     const timestamp = this.getTimestamp();
     let prefix = "";
     switch (level) {
@@ -134,80 +134,63 @@ class ModalityLogger {
     if (categroy) {
       prefix += ` [${categroy}]`;
     }
-    return { prefix, result: payload };
+    return prefix;
   }
   log(level, payload, categroy) {
     if (!this.shouldLog(level))
       return;
-    const { prefix, result } = this.format(level, payload, categroy);
+    const prefix = this.format(level, categroy);
+    console.group(prefix);
     switch (level) {
       case "debug":
-        console.debug(`
-`, prefix, result, `
-`);
+        console.debug(payload);
         break;
       case "info":
-        console.log(`
-`, prefix);
-        console.dir(result, {
+        console.dir(payload, {
           depth: null,
           colors: true,
           maxArrayLength: null
         });
-        console.log(`
-`);
         break;
       case "warn":
-        console.log(`
-`, prefix);
-        console.warn(result);
+        console.warn(payload);
         console.log(`
 `);
         break;
       case "error":
-        const error = result.error;
-        if (error instanceof Error) {
-          delete result.error;
+        const error = payload.error;
+        if (error instanceof Error || error.stack) {
+          delete payload.error;
           const { message, stack, ...restError } = error;
           if (stack) {
             if (Object.keys(restError).length) {
-              console.error(`
-`, prefix, restError, `
-`, stack, `
-`);
+              console.error(restError, `
+`, stack);
             } else {
-              console.error(`
-`, prefix, `
-`, stack, `
-`);
+              console.error(stack);
             }
           } else {
             if (message) {
-              result.error = message;
+              payload.error = message;
             }
-            console.error(`
-`, prefix, result, `
-`);
+            console.error(payload);
           }
         } else {
-          console.error(`
-`, prefix, result, `
-`);
+          console.error(payload);
         }
         break;
       case "success":
-        console.log(`
-`, prefix, result, `
-`);
+        console.error(payload);
         break;
     }
+    console.groupEnd();
   }
-  cook(message, data) {
-    const payload = typeof message === "string" ? { message } : message;
+  cook(payload, data) {
+    const newPayload = typeof payload === "string" ? { message: payload } : payload;
     if (data) {
-      payload.data = data;
+      newPayload.data = data;
     }
-    return payload;
+    return newPayload;
   }
   debug(message, data) {
     this.log("debug", this.cook(message, data));
@@ -246,7 +229,7 @@ function withErrorHandling(fn, operation) {
       return await fn(...args);
     } catch (error) {
       if (error instanceof ErrorCode) {
-        logger.error(`${operation || "Task operation"} failed: ${error.code}`, {
+        logger.error(`${operation || "Unknown operation"} failed: ${error.code}`, {
           code: error.code,
           cause: error.cause,
           stack: error.stack

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

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

package/dist/types/util_logger.d.ts

@@ -21,7 +21,7 @@ export declare class ModalityLogger {
      * For control display logging level, the level could not set by user.
      */
     log(level: LogLevel, payload: any, categroy?: string): void;
-    cook(message: any, data?: any): any;
+    cook(payload: any, data?: any): any;
     debug(message: string, data?: any): void;
     info(message: string, data?: any): void;
     warn(message: string, data?: any): void;

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.7",
+  "version": "0.6.0",
   "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",