@geenius/tools 0.1.0

package/packages/errors/solidjs/tsconfig.json

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

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

@@ -0,0 +1,21 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: {
+        index: 'src/index.ts',
+    },
+    format: ['esm'],
+    dts: true,
+    clean: true,
+    outDir: 'dist',
+    sourcemap: true,
+    external: [
+        'solid-js',
+        'solid-js/web',
+        'solid-js/store',
+        'lucide-solid',
+    ],
+    esbuildOptions(options) {
+        options.jsx = 'preserve'
+    },
+})

package/packages/errors/src/index.ts

@@ -0,0 +1,320 @@
+/**
+ * @geenius-tools/errors — Structured error handling
+ *
+ * Provides a hierarchy of typed errors for different error scenarios.
+ * Enables consistent error handling and formatting across the Geenius ecosystem.
+ */
+
+/**
+ * Error codes for different error types
+ */
+export enum ErrorCode {
+  // Generic
+  UNKNOWN = 'UNKNOWN',
+  VALIDATION = 'VALIDATION',
+  NOT_FOUND = 'NOT_FOUND',
+  UNAUTHORIZED = 'UNAUTHORIZED',
+  FORBIDDEN = 'FORBIDDEN',
+  CONFLICT = 'CONFLICT',
+  INTERNAL = 'INTERNAL',
+
+  // Auth-specific
+  INVALID_CREDENTIALS = 'INVALID_CREDENTIALS',
+  SESSION_EXPIRED = 'SESSION_EXPIRED',
+  MFA_REQUIRED = 'MFA_REQUIRED',
+  INVALID_TOKEN = 'INVALID_TOKEN',
+
+  // Database
+  DATABASE_ERROR = 'DATABASE_ERROR',
+  CONSTRAINT_VIOLATION = 'CONSTRAINT_VIOLATION',
+
+  // Network
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  TIMEOUT = 'TIMEOUT',
+
+  // Configuration
+  INVALID_CONFIG = 'INVALID_CONFIG',
+  MISSING_CONFIG = 'MISSING_CONFIG',
+}
+
+/**
+ * Base Geenius error with structured information
+ */
+export interface GeeniusErrorOptions {
+  /** Error code for classification */
+  code?: ErrorCode
+  /** User-friendly message */
+  message: string
+  /** Technical details */
+  cause?: Error | unknown
+  /** HTTP status code equivalent */
+  statusCode?: number
+  /** Contextual data */
+  context?: Record<string, unknown>
+  /** Whether error should be logged */
+  log?: boolean
+}
+
+/**
+ * Structured error class for Geenius packages
+ *
+ * @example
+ * ```ts
+ * throw new GeeniusError({
+ *   code: ErrorCode.VALIDATION,
+ *   message: 'Invalid email format',
+ *   statusCode: 400,
+ *   context: { field: 'email' }
+ * })
+ * ```
+ */
+export class GeeniusError extends Error {
+  readonly code: ErrorCode
+  readonly statusCode: number
+  readonly context: Record<string, unknown>
+  readonly cause?: Error | unknown
+  readonly log: boolean
+
+  constructor(options: GeeniusErrorOptions) {
+    super(options.message)
+    this.name = 'GeeniusError'
+    this.code = options.code ?? ErrorCode.UNKNOWN
+    this.statusCode = options.statusCode ?? this.getDefaultStatusCode(this.code)
+    this.context = options.context ?? {}
+    this.cause = options.cause
+    this.log = options.log !== false
+
+    // Maintain proper prototype chain
+    Object.setPrototypeOf(this, GeeniusError.prototype)
+  }
+
+  /**
+   * Gets HTTP status code for error code
+   */
+  private getDefaultStatusCode(code: ErrorCode): number {
+    const statusMap: Record<ErrorCode, number> = {
+      [ErrorCode.UNKNOWN]: 500,
+      [ErrorCode.VALIDATION]: 400,
+      [ErrorCode.NOT_FOUND]: 404,
+      [ErrorCode.UNAUTHORIZED]: 401,
+      [ErrorCode.FORBIDDEN]: 403,
+      [ErrorCode.CONFLICT]: 409,
+      [ErrorCode.INTERNAL]: 500,
+      [ErrorCode.INVALID_CREDENTIALS]: 401,
+      [ErrorCode.SESSION_EXPIRED]: 401,
+      [ErrorCode.MFA_REQUIRED]: 403,
+      [ErrorCode.INVALID_TOKEN]: 401,
+      [ErrorCode.DATABASE_ERROR]: 500,
+      [ErrorCode.CONSTRAINT_VIOLATION]: 409,
+      [ErrorCode.NETWORK_ERROR]: 502,
+      [ErrorCode.TIMEOUT]: 504,
+      [ErrorCode.INVALID_CONFIG]: 500,
+      [ErrorCode.MISSING_CONFIG]: 500,
+    }
+    return statusMap[code]
+  }
+
+  /**
+   * Converts error to JSON for serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      context: this.context,
+      ...(this.cause && { cause: formatError(this.cause) }),
+    }
+  }
+
+  /**
+   * Converts error to string representation
+   */
+  toString(): string {
+    return `${this.name} [${this.code}]: ${this.message}`
+  }
+}
+
+/**
+ * Validation error for form/input validation failures
+ *
+ * @example
+ * ```ts
+ * throw new ValidationError({
+ *   message: 'Invalid input',
+ *   context: { errors: { email: 'Invalid format' } }
+ * })
+ * ```
+ */
+export class ValidationError extends GeeniusError {
+  constructor(options: Omit<GeeniusErrorOptions, 'code' | 'statusCode'>) {
+    super({
+      ...options,
+      code: ErrorCode.VALIDATION,
+      statusCode: 400,
+    })
+    this.name = 'ValidationError'
+    Object.setPrototypeOf(this, ValidationError.prototype)
+  }
+}
+
+/**
+ * Authentication error
+ */
+export class AuthError extends GeeniusError {
+  constructor(options: Omit<GeeniusErrorOptions, 'code' | 'statusCode'>) {
+    super({
+      ...options,
+      code: options.code ?? ErrorCode.INVALID_CREDENTIALS,
+      statusCode: 401,
+    })
+    this.name = 'AuthError'
+    Object.setPrototypeOf(this, AuthError.prototype)
+  }
+}
+
+/**
+ * Not found error
+ */
+export class NotFoundError extends GeeniusError {
+  constructor(options: Omit<GeeniusErrorOptions, 'code' | 'statusCode'>) {
+    super({
+      ...options,
+      code: ErrorCode.NOT_FOUND,
+      statusCode: 404,
+    })
+    this.name = 'NotFoundError'
+    Object.setPrototypeOf(this, NotFoundError.prototype)
+  }
+}
+
+/**
+ * Conflict error (e.g., duplicate key)
+ */
+export class ConflictError extends GeeniusError {
+  constructor(options: Omit<GeeniusErrorOptions, 'code' | 'statusCode'>) {
+    super({
+      ...options,
+      code: ErrorCode.CONFLICT,
+      statusCode: 409,
+    })
+    this.name = 'ConflictError'
+    Object.setPrototypeOf(this, ConflictError.prototype)
+  }
+}
+
+/**
+ * Formats any error into structured format
+ *
+ * @param error Error to format
+ * @returns Formatted error object
+ */
+export function formatError(error: unknown): Record<string, unknown> {
+  if (error instanceof GeeniusError) {
+    return error.toJSON()
+  }
+
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    }
+  }
+
+  if (typeof error === 'string') {
+    return { message: error }
+  }
+
+  if (typeof error === 'object' && error !== null) {
+    return error as Record<string, unknown>
+  }
+
+  return { message: String(error) }
+}
+
+/**
+ * Type guard to check if error is GeeniusError
+ *
+ * @param error Error to check
+ * @returns True if error is GeeniusError
+ */
+export function isGeeniusError(error: unknown): error is GeeniusError {
+  return error instanceof GeeniusError
+}
+
+/**
+ * Type guard to check if error is a specific error code
+ *
+ * @param error Error to check
+ * @param code Error code to match
+ * @returns True if error has specified code
+ */
+export function isErrorCode(error: unknown, code: ErrorCode): boolean {
+  return isGeeniusError(error) && error.code === code
+}
+
+/**
+ * Wraps a promise to catch and transform errors
+ *
+ * @param promise Promise to wrap
+ * @param handler Error transformation function
+ * @returns Promise with transformed errors
+ *
+ * @example
+ * ```ts
+ * const result = await catchError(
+ *   fetchApi(),
+ *   (err) => new GeeniusError({
+ *     code: ErrorCode.NETWORK_ERROR,
+ *     message: 'API request failed',
+ *     cause: err
+ *   })
+ * )
+ * ```
+ */
+export async function catchError<T>(
+  promise: Promise<T>,
+  handler: (error: unknown) => Error
+): Promise<T> {
+  try {
+    return await promise
+  } catch (error) {
+    throw handler(error)
+  }
+}
+
+/**
+ * Creates a safe function that handles errors
+ *
+ * @param fn Function to wrap
+ * @param handler Error transformation
+ * @returns Safe version of function
+ *
+ * @example
+ * ```ts
+ * const safeOp = makeSafe(
+ *   (id: string) => db.user.find(id),
+ *   (err) => new NotFoundError({ message: 'User not found', cause: err })
+ * )
+ * ```
+ */
+export function makeSafe<T extends (...args: any[]) => any>(
+  fn: T,
+  handler: (error: unknown) => Error
+): T {
+  return ((...args: any[]) => {
+    try {
+      const result = fn(...args)
+      if (result instanceof Promise) {
+        return result.catch((err: unknown) => {
+          throw handler(err)
+        })
+      }
+      return result
+    } catch (error) {
+      throw handler(error)
+    }
+  }) as T
+}

package/packages/errors/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/logger/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@geenius-tools/logger",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Structured logging 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/logger/react/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-tools/logger-react\n\n> React hooks for @geenius-tools/logger\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/logger-react\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-tools/logger-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/logger/react/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@geenius-tools/logger-react",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "React hooks for @geenius-tools/logger",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "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",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "dependencies": {
+    "@geenius-tools/logger": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "react": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "author": "Antigravity HQ",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

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

@@ -0,0 +1,4 @@
+// @geenius-tools/logger-react — src/index.ts
+
+export { usePerformanceLog } from './usePerformanceLog'
+export { useMetrics } from './useMetrics'

package/packages/logger/react/src/useMetrics.ts

@@ -0,0 +1,42 @@
+// @geenius-tools/logger-react — src/useMetrics.ts
+
+import { useState, useEffect, useCallback } from 'react'
+import { metricsStore, type PerformanceMetric, type MetricsStore } from '@geenius-tools/logger'
+
+/**
+ * React hook to subscribe to the MetricsStore.
+ * Returns the latest metrics array (reactive).
+ *
+ * @example
+ * ```tsx
+ * import { useMetrics } from '@geenius-tools/logger-react'
+ *
+ * function DevPanel() {
+ *   const metrics = useMetrics()
+ *
+ *   return (
+ *     <ul>
+ *       {metrics.map(m => (
+ *         <li key={m.id}>{m.name}: {m.duration?.toFixed(2)}ms</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
+ */
+export function useMetrics(store: MetricsStore = metricsStore) {
+    const [metrics, setMetrics] = useState<PerformanceMetric[]>(() => store.getMetrics())
+
+    const handleNewMetrics = useCallback(() => {
+        setMetrics([...store.getMetrics()])
+    }, [store])
+
+    useEffect(() => {
+        const unsubscribe = store.subscribe(() => {
+            handleNewMetrics()
+        })
+        return unsubscribe
+    }, [store, handleNewMetrics])
+
+    return metrics
+}

package/packages/logger/react/src/usePerformanceLog.ts

@@ -0,0 +1,61 @@
+// @geenius-tools/logger-react — src/usePerformanceLog.ts
+
+import { useMemo } from 'react'
+import {
+    perfLog,
+    type LogCategory,
+    type PerformanceLogger,
+} from '@geenius-tools/logger'
+
+/**
+ * React hook for component-scoped performance logging.
+ *
+ * @example
+ * ```tsx
+ * import { usePerformanceLog } from '@geenius-tools/logger-react'
+ *
+ * function MyComponent() {
+ *   const perf = usePerformanceLog('MyComponent')
+ *
+ *   useEffect(() => {
+ *     perf.logMount()
+ *     return () => perf.logUnmount()
+ *   }, [])
+ *
+ *   perf.logRender()
+ *
+ *   const handleClick = async () => {
+ *     const end = perf.start('fetch data', 'query')
+ *     await fetchData()
+ *     end()
+ *   }
+ * }
+ * ```
+ */
+export function usePerformanceLog(
+    componentName: string,
+    logger: PerformanceLogger = perfLog,
+) {
+    return useMemo(
+        () => ({
+            /** 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 a useEffect 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),
+        }),
+        [componentName, logger],
+    )
+}

package/packages/logger/react/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "jsx": "react-jsx",
+        "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/react/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: ['react', '@geenius-tools/logger'],
+})

package/packages/logger/solidjs/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-tools/logger-solidjs\n\n> SolidJS primitives for @geenius-tools/logger\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/logger-solidjs\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-tools/logger-solidjs';\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/logger/solidjs/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@geenius-tools/logger-solidjs",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "SolidJS primitives for @geenius-tools/logger",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "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",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "dependencies": {
+    "@geenius-tools/logger": "workspace:*"
+  },
+  "devDependencies": {
+    "solid-js": "^1.9.0",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.9.0"
+  },
+  "author": "Antigravity HQ",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}