@talex-touch/utils 1.0.42 → 1.0.44

package/common/logger/transport-logger.ts

@@ -0,0 +1,234 @@
+/**
+ * TuffTransport Logger
+ *
+ * Specialized logger for TuffTransport system with green branding.
+ * Used for IPC communication, events, and transport-related operations.
+ */
+
+import { LogLevel } from './types'
+
+/**
+ * ANSI color codes
+ */
+const COLORS = {
+  reset: '\x1B[0m',
+  gray: '\x1B[90m',
+  green: '\x1B[32m',
+  bgGreen: '\x1B[42m',
+  white: '\x1B[37m',
+  yellow: '\x1B[33m',
+  red: '\x1B[31m',
+  cyan: '\x1B[36m',
+  bold: '\x1B[1m',
+}
+
+/**
+ * TuffTransport Logger
+ *
+ * Outputs with distinctive green branding:
+ * [TuffTransport] [module] message
+ */
+export class TuffTransportLogger {
+  private readonly module: string
+  private readonly subModule?: string
+  private enabled: boolean
+  private level: LogLevel
+
+  constructor(
+    module: string,
+    options?: { subModule?: string, enabled?: boolean, level?: LogLevel },
+  ) {
+    this.module = module
+    this.subModule = options?.subModule
+    this.enabled = options?.enabled ?? true
+    this.level = options?.level ?? LogLevel.INFO
+  }
+
+  /**
+   * Check if logger is enabled
+   */
+  isEnabled(): boolean {
+    return this.enabled
+  }
+
+  /**
+   * Set enabled state
+   */
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled
+  }
+
+  /**
+   * Get log level
+   */
+  getLevel(): LogLevel {
+    return this.level
+  }
+
+  /**
+   * Set log level
+   */
+  setLevel(level: LogLevel): void {
+    this.level = level
+  }
+
+  /**
+   * Log debug message
+   */
+  debug(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.DEBUG, message, args)
+  }
+
+  /**
+   * Log info message
+   */
+  info(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.INFO, message, args)
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.WARN, message, args)
+  }
+
+  /**
+   * Log error message
+   */
+  error(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.ERROR, message, args)
+  }
+
+  /**
+   * Log event dispatch
+   */
+  event(eventName: string, direction: 'send' | 'receive', data?: unknown): void {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return
+
+    const arrow = direction === 'send' ? '→' : '←'
+    const dirLabel = direction === 'send' ? 'SEND' : 'RECV'
+    const prefix = this.buildPrefix()
+
+    console.debug(
+      `${prefix} ${COLORS.cyan}${arrow} ${dirLabel}${COLORS.reset} ${eventName}`,
+      data !== undefined ? data : '',
+    )
+  }
+
+  /**
+   * Log IPC invoke
+   */
+  invoke(channel: string, payload?: unknown): void {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return
+
+    const prefix = this.buildPrefix()
+    console.debug(`${prefix} ${COLORS.cyan}⚡ INVOKE${COLORS.reset} ${channel}`, payload ?? '')
+  }
+
+  /**
+   * Log IPC response
+   */
+  response(channel: string, result?: unknown, error?: unknown): void {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return
+
+    const prefix = this.buildPrefix()
+    if (error) {
+      console.debug(`${prefix} ${COLORS.red}✗ RESPONSE${COLORS.reset} ${channel}`, error)
+    }
+    else {
+      console.debug(`${prefix} ${COLORS.green}✓ RESPONSE${COLORS.reset} ${channel}`, result ?? '')
+    }
+  }
+
+  /**
+   * Create child logger with sub-module
+   */
+  child(subModule: string): TuffTransportLogger {
+    return new TuffTransportLogger(this.module, {
+      subModule: this.subModule ? `${this.subModule}:${subModule}` : subModule,
+      enabled: this.enabled,
+      level: this.level,
+    })
+  }
+
+  /**
+   * Check if should log
+   */
+  private shouldLog(level: LogLevel): boolean {
+    return this.enabled && level >= this.level
+  }
+
+  /**
+   * Build log prefix
+   */
+  private buildPrefix(): string {
+    const brand = `${COLORS.bgGreen}${COLORS.white}${COLORS.bold} TuffTransport ${COLORS.reset}`
+    const moduleLabel = this.subModule
+      ? `${COLORS.green}[${this.module}:${this.subModule}]${COLORS.reset}`
+      : `${COLORS.green}[${this.module}]${COLORS.reset}`
+
+    return `${brand} ${moduleLabel}`
+  }
+
+  /**
+   * Core log method
+   */
+  private log(level: LogLevel, message: string, args: unknown[]): void {
+    if (!this.shouldLog(level))
+      return
+
+    const prefix = this.buildPrefix()
+    const levelColors: Record<LogLevel, string> = {
+      [LogLevel.DEBUG]: COLORS.gray,
+      [LogLevel.INFO]: COLORS.green,
+      [LogLevel.WARN]: COLORS.yellow,
+      [LogLevel.ERROR]: COLORS.red,
+      [LogLevel.NONE]: '',
+    }
+    const color = levelColors[level] ?? ''
+
+    const output = `${prefix} ${color}${message}${COLORS.reset}`
+
+    switch (level) {
+      case LogLevel.DEBUG:
+        console.debug(output, ...args)
+        break
+      case LogLevel.INFO:
+        console.info(output, ...args)
+        break
+      case LogLevel.WARN:
+        console.warn(output, ...args)
+        break
+      case LogLevel.ERROR:
+        console.error(output, ...args)
+        break
+      default:
+        console.log(output, ...args)
+    }
+  }
+}
+
+/**
+ * Create TuffTransport logger for a module
+ */
+export function createTransportLogger(
+  module: string,
+  options?: { subModule?: string, enabled?: boolean, level?: LogLevel },
+): TuffTransportLogger {
+  return new TuffTransportLogger(module, options)
+}
+
+/**
+ * Default transport loggers for common modules
+ */
+export const transportLoggers = {
+  flowBus: new TuffTransportLogger('FlowBus'),
+  coreBox: new TuffTransportLogger('CoreBox'),
+  plugin: new TuffTransportLogger('Plugin'),
+  storage: new TuffTransportLogger('Storage'),
+  divisionBox: new TuffTransportLogger('DivisionBox'),
+}

package/common/logger/types.ts

@@ -0,0 +1,93 @@
+/**
+ * Module Logger Types
+ *
+ * Unified logging system for Talex Touch modules.
+ * Uses unified LogLevel from base.
+ */
+
+import type { LogLevelStringLower } from '../../base/log-level'
+import {
+  stringToLogLevel as baseStringToLogLevel,
+  LogLevel,
+
+  logLevelToLowerString,
+} from '../../base/log-level'
+
+// Re-export LogLevel for convenience
+export { LogLevel }
+
+/**
+ * Log level string type (lowercase for config files)
+ */
+export type LogLevelString = LogLevelStringLower
+
+/**
+ * Convert LogLevel to lowercase string (for config)
+ */
+export function logLevelToString(level: LogLevel): LogLevelString {
+  return logLevelToLowerString(level)
+}
+
+/**
+ * Convert string to LogLevel
+ */
+export function stringToLogLevel(str: LogLevelString): LogLevel {
+  return baseStringToLogLevel(str)
+}
+
+/**
+ * Module logger options
+ */
+export interface ModuleLoggerOptions {
+  /** Module name (unique identifier) */
+  module: string
+  /** Log color (chalk color name) */
+  color?: string
+  /** Initial enabled state */
+  enabled?: boolean
+  /** Minimum log level */
+  level?: LogLevel
+  /** Custom prefix */
+  prefix?: string
+}
+
+/**
+ * Logging configuration
+ */
+export interface LoggingConfig {
+  /** Global enabled switch */
+  enabled: boolean
+  /** Global log level */
+  globalLevel: LogLevelString
+  /** Per-module configuration */
+  modules: Record<string, ModuleConfig>
+}
+
+/**
+ * Per-module configuration
+ */
+export interface ModuleConfig {
+  enabled: boolean
+  level: LogLevelString
+}
+
+/**
+ * Logger info for listing
+ */
+export interface LoggerInfo {
+  module: string
+  enabled: boolean
+  level: LogLevel
+  color: string
+}
+
+/**
+ * Log entry
+ */
+export interface LogEntry {
+  timestamp: string
+  module: string
+  level: LogLevel
+  message: string
+  data?: unknown[]
+}

package/common/search/gather.ts

@@ -1,35 +1,77 @@
 import type { TuffUpdate } from '.'
 
+/**
+ * Search priority layer type
+ */
+export type SearchPriorityLayer = 'fast' | 'deferred'
+
 /**
  * @interface ITuffGatherOptions
  * @description Configuration options for the search result aggregator.
  */
 export interface ITuffGatherOptions {
   /**
-   * The number of providers to run in parallel.
-   * @default 3
+   * The number of providers to run in parallel (legacy, used when layered mode is disabled).
+   * @default 4
    */
   concurrency?: number
   /**
    * The time to wait for more results before flushing the buffer.
-   * @default 100
+   * @default 50
    */
   coalesceGapMs?: number
   /**
    * A shorter grace period for the first batch to ensure a quick initial response.
-   * @default 50
+   * @default 20
    */
   firstBatchGraceMs?: number
   /**
    * A small debounce delay for the push function to avoid rapid-fire updates.
-   * @default 10
+   * @default 8
    */
   debouncePushMs?: number
   /**
    * The maximum time to wait for a single provider to return results.
-   * @default 5000
+   * @default 3000
    */
   taskTimeoutMs?: number
+
+  // ==================== Layered Search Options ====================
+
+  /**
+   * Enable layered search mode (fast layer + deferred layer).
+   * When enabled, providers with priority='fast' run first with a timeout,
+   * then deferred providers run asynchronously.
+   * @default true
+   */
+  enableLayeredSearch?: boolean
+
+  /**
+   * Maximum wait time for all fast layer providers.
+   * After this timeout, fast layer results are returned immediately,
+   * even if some fast providers haven't completed.
+   * @default 80
+   */
+  fastLayerTimeoutMs?: number
+
+  /**
+   * Delay before starting deferred layer execution.
+   * Allows UI to render fast layer results first, avoiding CPU contention.
+   * @default 50
+   */
+  deferredLayerDelayMs?: number
+
+  /**
+   * Concurrency limit for fast layer providers.
+   * @default 3
+   */
+  fastLayerConcurrency?: number
+
+  /**
+   * Concurrency limit for deferred layer providers.
+   * @default 2
+   */
+  deferredLayerConcurrency?: number
 }
 
 /**

package/common/search/index.ts

@@ -1,4 +1,5 @@
 import type { ISearchProvider, TuffQuery, TuffSearchResult } from '@talex-touch/utils'
+import type { SearchPriorityLayer } from './gather'
 
 export * from './gather'
 
@@ -28,6 +29,13 @@ export interface TuffUpdate {
    * Statistics about the performance of each search provider.
    */
   sourceStats?: TuffSearchResult['sources']
+  /**
+   * Indicates which layer this update came from.
+   * - 'fast': Results from fast layer providers
+   * - 'deferred': Results from deferred layer providers
+   * Useful for UI to handle different layers appropriately.
+   */
+  layer?: SearchPriorityLayer
 }
 
 /**

package/common/storage/constants.ts

@@ -2,8 +2,21 @@ export enum StorageList {
   APP_SETTING = 'app-setting.ini',
   SHORTCUT_SETTING = 'shortcut-setting.ini',
   OPENERS = 'openers.json',
+  FILE_INDEX_SETTINGS = 'file-index-settings.json',
+  APP_INDEX_SETTINGS = 'app-index-settings.json',
+  DEVICE_IDLE_SETTINGS = 'device-idle-settings.json',
   IntelligenceConfig = 'aisdk-config',
   MARKET_SOURCES = 'market-sources.json',
+  AGENT_MARKET = 'agent-market.json',
+  THEME_STYLE = 'theme-style.ini',
+  SEARCH_ENGINE_LOGS_ENABLED = 'search-engine-logs-enabled',
+  EVERYTHING_SETTINGS = 'everything-settings.json',
+  FLOW_CONSENT = 'flow-consent.json',
+  SENTRY_CONFIG = 'sentry-config.json',
+  NOTIFICATION_CENTER = 'notification-center.json',
+  STARTUP_ANALYTICS = 'startup-analytics.json',
+  STARTUP_ANALYTICS_REPORT_QUEUE = 'startup-analytics-report-queue.json',
+  TELEMETRY_CLIENT = 'telemetry-client.json',
 }
 
 /**