@geenius/tools 0.1.0 → 0.3.0

package/packages/errors/solidjs/tsconfig.json

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

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

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

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

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

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

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

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

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

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

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

@@ -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: ['react', '@geenius-tools/logger'],
-})

package/packages/logger/solidjs/package.json

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

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

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