@geenius/tools 0.1.0 → 0.3.0

package/packages/logger/solidjs/src/createPerformanceLog.ts

@@ -1,58 +0,0 @@
-// @geenius-tools/logger-solid — src/createPerformanceLog.ts
-
-import {
-    perfLog,
-    type LogCategory,
-    type PerformanceLogger,
-} from '@geenius-tools/logger'
-
-/**
- * SolidJS helper for component-scoped performance logging.
- *
- * @example
- * ```tsx
- * import { createPerformanceLog } from '@geenius-tools/logger-solidjs'
- *
- * function MyComponent() {
- *   const perf = createPerformanceLog('MyComponent')
- *
- *   onMount(() => {
- *     perf.logMount()
- *   })
- *
- *   onCleanup(() => {
- *     perf.logUnmount()
- *   })
- *
- *   const handleClick = async () => {
- *     const end = perf.start('fetch data', 'query')
- *     await fetchData()
- *     end()
- *   }
- * }
- * ```
- */
-export function createPerformanceLog(
-    componentName: string,
-    logger: PerformanceLogger = perfLog,
-) {
-    return {
-        /** Log component mounted */
-        logMount: () =>
-            logger.log(componentName, 'Component mounted', undefined, 'component'),
-        /** Log component unmounted */
-        logUnmount: () =>
-            logger.log(componentName, 'Component unmounted', undefined, 'component'),
-        /** Track render count */
-        logRender: () => logger.renderCount(componentName),
-        /** Log an effect execution */
-        logEffect: (effectName: string) =>
-            logger.log(componentName, `Effect: ${effectName}`, undefined, 'effect'),
-        /** Start a timed operation, returns stop function */
-        start: (operation: string, category?: LogCategory) =>
-            logger.start(componentName, operation, category),
-        /** Generic log scoped to this component */
-        log: (message: string, data?: unknown, category?: LogCategory) =>
-            logger.log(componentName, message, data, category),
-    }
-}

package/packages/logger/solidjs/src/index.ts

@@ -1,4 +0,0 @@
-// @geenius-tools/logger-solid — src/index.ts
-
-export { createPerformanceLog } from './createPerformanceLog'
-export { createMetrics } from './createMetrics'

package/packages/logger/solidjs/tsconfig.json

@@ -1,32 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "ESNext",
-        "moduleResolution": "bundler",
-        "jsx": "preserve",
-        "jsxImportSource": "solid-js",
-        "lib": [
-            "ES2022",
-            "DOM",
-            "DOM.Iterable"
-        ],
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "isolatedModules": true,
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true,
-        "outDir": "./dist",
-        "rootDir": "./src"
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}

package/packages/logger/solidjs/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: { index: 'src/index.ts' },
-    outDir: 'dist',
-    format: ['esm'],
-    dts: true,
-    sourcemap: true,
-    clean: true,
-    treeshake: true,
-    external: ['solid-js', '@geenius-tools/logger'],
-})

package/packages/logger/src/index.ts

@@ -1,363 +0,0 @@
-/**
- * @geenius-tools/logger — Structured logging
- *
- * Provides structured logging with levels, formatting, and contextual data.
- * Suitable for both client and server environments.
- */
-
-/**
- * Log levels in order of severity
- */
-export enum LogLevel {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-  FATAL = 4,
-}
-
-/**
- * Log entry structure
- */
-export interface LogEntry {
-  /** Log level */
-  level: LogLevel
-  /** Log message */
-  message: string
-  /** Contextual data */
-  context?: Record<string, unknown>
-  /** Error object if applicable */
-  error?: Error | unknown
-  /** Timestamp */
-  timestamp: Date
-  /** Additional metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Log formatter function
- */
-export type LogFormatter = (entry: LogEntry) => string
-
-/**
- * Logger transport (where logs go)
- */
-export interface LogTransport {
-  /** Log handler function */
-  log(entry: LogEntry): void | Promise<void>
-}
-
-/**
- * Logger configuration
- */
-export interface LoggerConfig {
-  /** Minimum log level to output (default: INFO) */
-  level?: LogLevel
-  /** Custom formatter (default: pretty print) */
-  formatter?: LogFormatter
-  /** Log transports */
-  transports?: LogTransport[]
-  /** Whether to include timestamps (default: true) */
-  timestamps?: boolean
-  /** Whether to include source location (default: false) */
-  sourceLocation?: boolean
-}
-
-/**
- * Structured logger with context and levels
- *
- * @example
- * ```ts
- * const logger = createLogger({ level: LogLevel.DEBUG })
- *
- * logger.info('User signed in', { userId: '123' })
- * logger.error('Database error', { error })
- * logger.debug('Cache hit', { key: 'user:123' })
- * ```
- */
-export class Logger {
-  private level: LogLevel
-  private formatter: LogFormatter
-  private transports: LogTransport[]
-  private timestamps: boolean
-  private sourceLocation: boolean
-  private context: Map<string, unknown> = new Map()
-
-  constructor(config: LoggerConfig = {}) {
-    this.level = config.level ?? LogLevel.INFO
-    this.formatter = config.formatter ?? defaultFormatter
-    this.transports = config.transports ?? [consoleTransport]
-    this.timestamps = config.timestamps !== false
-    this.sourceLocation = config.sourceLocation ?? false
-  }
-
-  /**
-   * Logs with debug level
-   */
-  debug(message: string, context?: Record<string, unknown>) {
-    this.log(LogLevel.DEBUG, message, context)
-  }
-
-  /**
-   * Logs with info level
-   */
-  info(message: string, context?: Record<string, unknown>) {
-    this.log(LogLevel.INFO, message, context)
-  }
-
-  /**
-   * Logs with warn level
-   */
-  warn(message: string, context?: Record<string, unknown>) {
-    this.log(LogLevel.WARN, message, context)
-  }
-
-  /**
-   * Logs with error level
-   */
-  error(message: string, error?: Error | unknown, context?: Record<string, unknown>) {
-    this.log(LogLevel.ERROR, message, context, error)
-  }
-
-  /**
-   * Logs with fatal level
-   */
-  fatal(message: string, error?: Error | unknown, context?: Record<string, unknown>) {
-    this.log(LogLevel.FATAL, message, context, error)
-  }
-
-  /**
-   * Core logging method
-   */
-  private log(
-    level: LogLevel,
-    message: string,
-    context?: Record<string, unknown>,
-    error?: Error | unknown
-  ) {
-    if (level < this.level) {
-      return
-    }
-
-    const mergedContext = {
-      ...Object.fromEntries(this.context),
-      ...context,
-    }
-
-    const entry: LogEntry = {
-      level,
-      message,
-      context: Object.keys(mergedContext).length > 0 ? mergedContext : undefined,
-      error,
-      timestamp: new Date(),
-    }
-
-    if (this.sourceLocation) {
-      entry.metadata = {
-        ...entry.metadata,
-        location: this.getSourceLocation(),
-      }
-    }
-
-    const formatted = this.formatter(entry)
-
-    for (const transport of this.transports) {
-      try {
-        void transport.log(entry)
-      } catch {
-        // Silently fail to prevent logger errors from breaking app
-      }
-    }
-  }
-
-  /**
-   * Sets context for all subsequent logs
-   */
-  setContext(key: string, value: unknown) {
-    this.context.set(key, value)
-    return this
-  }
-
-  /**
-   * Gets current context
-   */
-  getContext(): Record<string, unknown> {
-    return Object.fromEntries(this.context)
-  }
-
-  /**
-   * Clears context
-   */
-  clearContext() {
-    this.context.clear()
-    return this
-  }
-
-  /**
-   * Creates a child logger with inherited context
-   */
-  child(context: Record<string, unknown>): Logger {
-    const child = new Logger({
-      level: this.level,
-      formatter: this.formatter,
-      transports: this.transports,
-      timestamps: this.timestamps,
-      sourceLocation: this.sourceLocation,
-    })
-
-    // Inherit context
-    for (const [key, value] of this.context) {
-      child.setContext(key, value)
-    }
-
-    // Add child context
-    for (const [key, value] of Object.entries(context)) {
-      child.setContext(key, value)
-    }
-
-    return child
-  }
-
-  /**
-   * Gets source location from stack trace
-   */
-  private getSourceLocation(): { file: string; line: number } {
-    const stack = new Error().stack || ''
-    const lines = stack.split('\n')
-
-    // Skip error message and this method
-    for (let i = 2; i < lines.length; i++) {
-      const line = lines[i]
-      if (line.includes('Logger.') || line.includes('logger.')) {
-        continue
-      }
-
-      const match = line.match(/at\s+(?:.*?\s+)?\(?([^:\)]+):(\d+)/)
-      if (match) {
-        return {
-          file: match[1],
-          line: parseInt(match[2]),
-        }
-      }
-    }
-
-    return { file: 'unknown', line: 0 }
-  }
-}
-
-/**
- * Default log formatter with colors (for terminal)
- */
-const defaultFormatter: LogFormatter = (entry: LogEntry) => {
-  const levelName = LogLevel[entry.level]
-  const timestamp = entry.timestamp.toISOString()
-
-  let output = `[${timestamp}] [${levelName}] ${entry.message}`
-
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    output += ` ${JSON.stringify(entry.context)}`
-  }
-
-  if (entry.error) {
-    const errorStr =
-      entry.error instanceof Error
-        ? `${entry.error.name}: ${entry.error.message}`
-        : String(entry.error)
-    output += ` Error: ${errorStr}`
-  }
-
-  return output
-}
-
-/**
- * Console transport for logging to stdout/stderr
- */
-export const consoleTransport: LogTransport = {
-  log(entry: LogEntry) {
-    const formatted = defaultFormatter(entry)
-
-    if (entry.level >= LogLevel.ERROR) {
-      console.error(formatted)
-    } else if (entry.level === LogLevel.WARN) {
-      console.warn(formatted)
-    } else {
-      console.log(formatted)
-    }
-  },
-}
-
-/**
- * Creates a new logger instance
- *
- * @param config Logger configuration
- * @returns Configured logger
- *
- * @example
- * ```ts
- * const logger = createLogger({
- *   level: LogLevel.DEBUG,
- *   timestamps: true
- * })
- * ```
- */
-export function createLogger(config?: LoggerConfig): Logger {
-  return new Logger(config)
-}
-
-/**
- * Global default logger instance
- */
-let globalLogger: Logger | null = null
-
-/**
- * Gets or creates global logger
- *
- * @param config Configuration for initial creation
- * @returns Global logger instance
- */
-export function getGlobalLogger(config?: LoggerConfig): Logger {
-  if (!globalLogger) {
-    globalLogger = createLogger(config)
-  }
-  return globalLogger
-}
-
-/**
- * Resets global logger (for testing)
- */
-export function resetGlobalLogger() {
-  globalLogger = null
-}
-
-/**
- * Memory transport for testing and analysis
- */
-export class MemoryTransport implements LogTransport {
-  private entries: LogEntry[] = []
-
-  log(entry: LogEntry) {
-    this.entries.push(entry)
-  }
-
-  /** Gets all logged entries */
-  getEntries(): LogEntry[] {
-    return [...this.entries]
-  }
-
-  /** Gets entries by level */
-  getByLevel(level: LogLevel): LogEntry[] {
-    return this.entries.filter((e) => e.level === level)
-  }
-
-  /** Clears all entries */
-  clear() {
-    this.entries = []
-  }
-
-  /** Gets count of entries */
-  size(): number {
-    return this.entries.length
-  }
-}
-
-export { LogLevel } from './index'

package/packages/logger/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-    },
-    format: ['esm'],
-    dts: true,
-    clean: true,
-    sourcemap: true,
-})
-

package/packages/perf/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "@geenius-tools/perf",
-  "version": "0.1.0",
-  "type": "module",
-  "description": "Performance monitoring utilities for Geenius projects",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "scripts": {
-    "build": "tsup",
-    "type-check": "tsc --noEmit",
-    "clean": "rm -rf dist .turbo"
-  },
-  "devDependencies": {
-    "typescript": "~6.0.2",
-    "tsup": "^8.0.1"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT"
-}

package/packages/perf/react/package.json

@@ -1,59 +0,0 @@
-{
-  "name": "@geenius-tools/perf-react",
-  "version": "0.1.0",
-  "private": false,
-  "description": "React performance monitoring \u2014 dashboard, metrics hooks, query tracking",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@geenius-ui/react": "workspace:*",
-    "@tanstack/react-query": "^5.91.3",
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "lucide-react": "^0.577.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "tsup": "^8.5.1",
-    "typescript": "~5.9.3"
-  },
-  "peerDependencies": {
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
-  },
-  "peerDependenciesMeta": {
-    "lucide-react": {
-      "optional": true
-    },
-    "@geenius-ui/react": {
-      "optional": true
-    },
-    "@tanstack/react-query": {
-      "optional": true
-    }
-  },
-  "author": "Antigravity HQ",
-  "license": "MIT",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}