@geenius/tools 0.1.0

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

@@ -0,0 +1,37 @@
+// @geenius-tools/logger-solid — src/createMetrics.ts
+
+import { createSignal, onCleanup } from 'solid-js'
+import { metricsStore, type PerformanceMetric, type MetricsStore } from '@geenius-tools/logger'
+
+/**
+ * SolidJS reactive primitive for subscribing to the MetricsStore.
+ *
+ * @example
+ * ```tsx
+ * import { createMetrics } from '@geenius-tools/logger-solidjs'
+ * import { For } from 'solid-js'
+ *
+ * function DevPanel() {
+ *   const metrics = createMetrics()
+ *
+ *   return (
+ *     <ul>
+ *       <For each={metrics()}>
+ *         {(m) => <li>{m.name}: {m.duration?.toFixed(2)}ms</li>}
+ *       </For>
+ *     </ul>
+ *   )
+ * }
+ * ```
+ */
+export function createMetrics(store: MetricsStore = metricsStore) {
+    const [metrics, setMetrics] = createSignal<PerformanceMetric[]>(store.getMetrics())
+
+    const unsubscribe = store.subscribe(() => {
+        setMetrics([...store.getMetrics()])
+    })
+
+    onCleanup(unsubscribe)
+
+    return metrics
+}

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

@@ -0,0 +1,58 @@
+// @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

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

package/packages/logger/solidjs/tsconfig.json

@@ -0,0 +1,32 @@
+{
+    "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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,363 @@
+/**
+ * @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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,27 @@
+{
+  "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/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-tools/perf-react\n\n> React performance monitoring — dashboard, metrics hooks, query tracking\n\n---\n\n## Overview\nBuilt with Steve Jobs-level minimalism and Jony Ive-level craftsmanship, this package is designed to deliver unparalleled developer experience (DX) and rock-solid performance.\n\n## Installation\n\n```bash\npnpm add @geenius-tools/perf-react\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-tools/perf-react';\n\n// Initialize the module with absolute precision\ninit({\n  mode: 'premium',\n});\n```\n\n## Architecture\n- **Zero-config**: It just works.\n- **Strictly Typed**: Fully written in TypeScript for flawless IntelliSense.\n- **Framework Agnostic**: seamlessly integrates into the Geenius ecosystem.\n\n---\n\n*Designed by Antigravity HQ*\n

package/packages/perf/react/package.json

@@ -0,0 +1,59 @@
+{
+  "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"
+  }
+}