@zintrust/core 0.1.28 → 0.1.29

package/src/cli/d1/WranglerD1.ts

@@ -1,28 +0,0 @@
-import { resolveNpmPath } from '@common/index';
-import { appConfig } from '@config/app';
-import { execFileSync } from '@node-singletons/child-process';
-
-import type { IBaseCommand } from '@cli/BaseCommand';
-
-type ApplyOptions = {
-  cmd: IBaseCommand;
-  dbName: string;
-  isLocal: boolean;
-};
-
-export const WranglerD1 = Object.freeze({
-  applyMigrations(opts: ApplyOptions): string {
-    const args = ['d1', 'migrations', 'apply', opts.dbName, opts.isLocal ? '--local' : '--remote'];
-    const npmPath = resolveNpmPath();
-
-    opts.cmd.debug(`Executing: npm exec --yes -- wrangler ${args.join(' ')}`);
-
-    const result = execFileSync(npmPath, ['exec', '--yes', '--', 'wrangler', ...args], {
-      stdio: 'pipe',
-      encoding: 'utf8',
-      env: appConfig.getSafeEnv(),
-    });
-
-    return result;
-  },
-});

package/src/cli/debug/Dashboard.ts

@@ -1,227 +0,0 @@
-/**
- * Debug Dashboard
- * Terminal-based real-time monitoring UI
- */
-
-import { randomInt } from '@node-singletons/crypto';
-import * as os from '@node-singletons/os';
-import * as readline from '@node-singletons/readline';
-import chalk from 'chalk';
-
-export interface DashboardStats {
-  uptime: number;
-  memory: {
-    total: number;
-    free: number;
-    used: number;
-  };
-  requests: {
-    total: number;
-    active: number;
-    avgDuration: number;
-  };
-  queries: {
-    total: number;
-    n1Warnings: number;
-  };
-}
-
-interface DashboardState {
-  stats: DashboardStats;
-  timer: NodeJS.Timeout | undefined;
-  rl: readline.Interface;
-}
-
-const formatBytes = (bytes: number): string => {
-  const units = ['B', 'KB', 'MB', 'GB'];
-  let size = bytes;
-  let i = 0;
-  while (size > 1024 && i < units.length - 1) {
-    size /= 1024;
-    i++;
-  }
-  return `${size.toFixed(2)} ${units[i]}`;
-};
-
-const formatDuration = (seconds: number): string => {
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor((seconds % 3600) / 60);
-  const s = Math.floor(seconds % 60);
-  return `${h}h ${m}m ${s}s`;
-};
-
-const getPercent = (value: number, total: number): string => {
-  return ((value / total) * 100).toFixed(1);
-};
-
-const hideCursor = (): void => {
-  process.stdout.write('\x1B[?25l');
-};
-
-const showCursor = (): void => {
-  process.stdout.write('\x1B[?25h');
-};
-
-const renderSection = (title: string, lines: string[]): void => {
-  process.stdout.write(chalk.cyan.bold(`\n[ ${title} ]`) + '\n');
-  lines.forEach((line) => process.stdout.write(`  ${line}\n`));
-};
-
-const render = (stats: DashboardStats): void => {
-  readline.cursorTo(process.stdout, 0, 0);
-
-  const header = chalk.bgBlue.white.bold(' ZINTRUST DEBUG DASHBOARD ');
-  const uptime = chalk.gray(`Uptime: ${formatDuration(stats.uptime)}`);
-
-  process.stdout.write(`${header} ${uptime}\n\n`);
-
-  renderSection('SYSTEM RESOURCES', [
-    `Memory: ${formatBytes(stats.memory.used)} / ${formatBytes(stats.memory.total)} (${getPercent(
-      stats.memory.used,
-      stats.memory.total
-    )}%)`,
-    `CPU Load: ${os.loadavg()[0].toFixed(2)}`,
-  ]);
-
-  renderSection('HTTP REQUESTS', [
-    `Total Requests: ${stats.requests.total}`,
-    `Active Requests: ${chalk.green(stats.requests.active)}`,
-    `Avg Duration: ${stats.requests.avgDuration}ms`,
-  ]);
-
-  renderSection('DATABASE QUERIES', [
-    `Total Queries: ${stats.queries.total}`,
-    `N+1 Warnings: ${
-      stats.queries.n1Warnings > 0 ? chalk.red.bold(stats.queries.n1Warnings) : chalk.green('0')
-    }`,
-  ]);
-
-  process.stdout.write('\n' + chalk.gray('Press Ctrl+C to exit') + '\n');
-};
-
-const updateStatsInternal = (stats: DashboardStats): void => {
-  const totalMem = os.totalmem();
-  const freeMem = os.freemem();
-
-  stats.uptime = process.uptime();
-  stats.memory = {
-    total: totalMem,
-    free: freeMem,
-    used: totalMem - freeMem,
-  };
-
-  // Mock some activity for demonstration
-  if (randomInt(0, 1000) > 700) {
-    stats.requests.total += randomInt(0, 3);
-    stats.requests.active = randomInt(0, 5);
-    stats.requests.avgDuration = randomInt(20, 120);
-  }
-
-  if (randomInt(0, 1000) > 800) {
-    stats.queries.total += randomInt(0, 10);
-    if (randomInt(0, 1000) > 900) {
-      stats.queries.n1Warnings++;
-    }
-  }
-};
-
-export interface IDashboard {
-  start(): void;
-  stop(): void;
-  update(newStats: Partial<DashboardStats>): void;
-}
-
-/**
- * Debug Dashboard
- * Terminal-based real-time monitoring UI
- * Sealed namespace for immutability
- */
-const DashboardFactory = Object.freeze({
-  create(): IDashboard {
-    const state: DashboardState = {
-      rl: readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      }),
-      stats: {
-        uptime: 0,
-        memory: { total: 0, free: 0, used: 0 },
-        requests: { total: 0, active: 0, avgDuration: 0 },
-        queries: { total: 0, n1Warnings: 0 },
-      },
-      timer: undefined,
-    };
-
-    const dashboard: IDashboard & { render(): void; updateStats(): void } = {
-      render(): void {
-        render(state.stats);
-      },
-
-      updateStats(): void {
-        updateStatsInternal(state.stats);
-      },
-
-      /**
-       * Start the dashboard
-       */
-      start(): void {
-        process.stdout.write('\x1Bc'); // Clear screen
-        hideCursor();
-        dashboard.render();
-
-        if (state.timer) {
-          clearInterval(state.timer);
-        }
-
-        state.timer = setInterval(() => {
-          dashboard.updateStats();
-          dashboard.render();
-        }, 1000);
-
-        // Ensure cleanup on exit
-        const cleanup = (): void => {
-          dashboard.stop();
-          process.exit(0);
-        };
-
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-      },
-
-      /**
-       * Stop the dashboard
-       */
-      stop(): void {
-        if (state.timer) {
-          clearInterval(state.timer);
-        }
-        showCursor();
-        state.rl.close();
-      },
-
-      /**
-       * Update dashboard stats
-       */
-      update(newStats: Partial<DashboardStats>): void {
-        state.stats = { ...state.stats, ...newStats };
-      },
-    };
-
-    return dashboard;
-  },
-});
-
-type DashboardCtor = {
-  new (): IDashboard;
-  (): IDashboard;
-  create(): IDashboard;
-};
-
-const DashboardCallable = function DashboardCallable(): IDashboard {
-  return DashboardFactory.create();
-};
-
-export const Dashboard = Object.assign(
-  DashboardCallable,
-  DashboardFactory
-) as unknown as DashboardCtor;

package/src/cli/env/EnvFileBackfill.ts

@@ -1,80 +0,0 @@
-import { readFileSync, writeFileSync } from '@node-singletons/fs';
-
-export type EnvBackfillResult = {
-  changed: boolean;
-  filledKeys: string[];
-  appendedKeys: string[];
-};
-
-const stripEnvInlineComment = (value: string): string => {
-  let inSingle = false;
-  let inDouble = false;
-
-  for (let i = 0; i < value.length; i += 1) {
-    const ch = value[i];
-    if (ch === "'" && !inDouble) inSingle = !inSingle;
-    if (ch === '"' && !inSingle) inDouble = !inDouble;
-
-    if (!inSingle && !inDouble && ch === '#') {
-      const prev = value[i - 1];
-      if (prev === undefined || prev === ' ' || prev === '\t') {
-        return value.slice(0, i).trimEnd();
-      }
-    }
-  }
-
-  return value;
-};
-
-const backfillEnvDefaults = (
-  envPath: string,
-  defaults: Record<string, string>
-): EnvBackfillResult => {
-  const raw = readFileSync(envPath, 'utf8');
-  const lines = raw.split(/\r?\n/);
-
-  const seen = new Set<string>();
-  const filledKeys: string[] = [];
-  const appendedKeys: string[] = [];
-
-  const out = lines.map((line) => {
-    const trimmed = line.trim();
-    if (trimmed === '' || trimmed.startsWith('#')) return line;
-
-    const withoutExport = trimmed.startsWith('export ') ? trimmed.slice('export '.length) : trimmed;
-    const eq = withoutExport.indexOf('=');
-    if (eq <= 0) return line;
-
-    const key = withoutExport.slice(0, eq).trim();
-    if (key === '') return line;
-    if (!Object.hasOwn(defaults, key)) return line;
-    if (seen.has(key)) return line;
-    seen.add(key);
-
-    const rhs = withoutExport.slice(eq + 1);
-    const withoutComment = stripEnvInlineComment(rhs);
-    const value = withoutComment.trim();
-
-    if (value !== '') return line;
-
-    filledKeys.push(key);
-    return `${key}=${defaults[key]}`;
-  });
-
-  const missingKeys = Object.keys(defaults).filter((k) => !seen.has(k));
-  if (missingKeys.length > 0) {
-    appendedKeys.push(...missingKeys);
-    out.push(...missingKeys.map((k) => `${k}=${defaults[k]}`));
-  }
-
-  const changed = filledKeys.length > 0 || appendedKeys.length > 0;
-  if (!changed) return { changed: false, filledKeys, appendedKeys };
-
-  writeFileSync(envPath, out.join('\n') + (out.at(-1) === '' ? '' : '\n'));
-  return { changed: true, filledKeys, appendedKeys };
-};
-
-export const EnvFileBackfill = Object.freeze({
-  stripEnvInlineComment,
-  backfillEnvDefaults,
-});

package/src/cli/index.ts

@@ -1,17 +0,0 @@
-/**
- * CLI Module Index
- * Exports all CLI components
- */
-
-export { BaseCommand, type CommandOptions } from '@cli/BaseCommand';
-export { CLI } from '@cli/CLI';
-export { ErrorHandler, EXIT_CODES } from '@cli/ErrorHandler';
-export { PromptHelper, type PromptOptions } from '@cli/PromptHelper';
-
-// Export commands
-export { AddCommand } from '@cli/commands/AddCommand';
-export { ConfigCommand } from '@cli/commands/ConfigCommand';
-export { DebugCommand } from '@cli/commands/DebugCommand';
-export { MigrateCommand } from '@cli/commands/MigrateCommand';
-export { NewCommand } from '@cli/commands/NewCommand';
-export { SecretsCommand } from '@cli/commands/SecretsCommand';

package/src/cli/logger/Logger.ts

@@ -1,193 +0,0 @@
-/**
- * Logger - File-Based Logging System
- * Logs to files with rotation, retention policies, and multiple log levels
- */
-
-import * as fs from '@node-singletons/fs';
-import * as path from '@node-singletons/path';
-
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-export interface LogEntry {
-  timestamp: string;
-  level: LogLevel;
-  message: string;
-  context?: string;
-  data?: Record<string, unknown>;
-}
-
-export interface LoggerInstance {
-  debug(message: string, data?: Record<string, unknown>, category?: string): void;
-  info(message: string, data?: Record<string, unknown>, category?: string): void;
-  warn(message: string, data?: Record<string, unknown>, category?: string): void;
-  error(message: string, data?: Record<string, unknown>, category?: string): void;
-  getLogs(category?: string, limit?: number): LogEntry[];
-  filterByLevel(logs: LogEntry[], level: LogLevel): LogEntry[];
-  filterByDateRange(logs: LogEntry[], startDate: Date, endDate: Date): LogEntry[];
-  clearLogs(category?: string): boolean;
-  getLogsDirectory(): string;
-  getLogLevel(): LogLevel;
-}
-
-const levelPriority: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-const ensureLogsDir = (logsDir: string): void => {
-  if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir, { recursive: true });
-  }
-};
-
-const getLogFilePath = (logsDir: string, category: string = 'app'): string => {
-  return path.join(logsDir, `${category}.log`);
-};
-
-const writeToLogFile = (
-  logsDir: string,
-  maxFileSize: number,
-  entry: LogEntry,
-  category: string = 'app'
-): void => {
-  ensureLogsDir(logsDir);
-  const logFile = getLogFilePath(logsDir, category);
-  const logString = JSON.stringify(entry) + '\n';
-
-  try {
-    // Check file size for rotation
-    if (fs.existsSync(logFile)) {
-      const stats = fs.statSync(logFile);
-      if (stats.size > maxFileSize) {
-        const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
-        fs.renameSync(logFile, `${logFile}.${timestamp}.bak`);
-      }
-    }
-
-    fs.appendFileSync(logFile, logString);
-  } catch (error) {
-    // Fallback to stderr if file logging fails
-    process.stderr.write(`Failed to write to log file: ${String(error)}\n`);
-  }
-};
-
-const log = (
-  logsDir: string,
-  maxFileSize: number,
-  currentLevel: LogLevel,
-  logLevel: LogLevel,
-  message: string,
-  data?: Record<string, unknown>,
-  category: string = 'app'
-): void => {
-  if (levelPriority[logLevel] < levelPriority[currentLevel]) {
-    return;
-  }
-
-  const entry: LogEntry = {
-    timestamp: new Date().toISOString(),
-    level: logLevel,
-    message,
-    data,
-    context: category,
-  };
-
-  writeToLogFile(logsDir, maxFileSize, entry, category);
-};
-
-export const Logger = Object.freeze({
-  /**
-   * Create a new logger instance
-   */
-  create(
-    logsDir: string = path.join(process.cwd(), 'logs'),
-    maxFileSize: number = 10 * 1024 * 1024, // 10MB
-    level: LogLevel = 'info'
-  ): LoggerInstance {
-    return {
-      debug(message: string, data?: Record<string, unknown>, category?: string): void {
-        log(logsDir, maxFileSize, level, 'debug', message, data, category);
-      },
-      info(message: string, data?: Record<string, unknown>, category?: string): void {
-        log(logsDir, maxFileSize, level, 'info', message, data, category);
-      },
-      warn(message: string, data?: Record<string, unknown>, category?: string): void {
-        log(logsDir, maxFileSize, level, 'warn', message, data, category);
-      },
-      error(message: string, data?: Record<string, unknown>, category?: string): void {
-        log(logsDir, maxFileSize, level, 'error', message, data, category);
-      },
-      getLogs(category: string = 'app', limit: number = 100): LogEntry[] {
-        const logFile = getLogFilePath(logsDir, category);
-        if (!fs.existsSync(logFile)) return [];
-
-        try {
-          const content = fs.readFileSync(logFile, 'utf-8');
-          return content
-            .split('\n')
-            .filter((line) => line.trim() !== '')
-            .map((line) => JSON.parse(line) as LogEntry)
-            .reverse()
-            .slice(0, limit);
-        } catch (error) {
-          process.stderr.write(`Failed to read logs: ${String(error)}\n`);
-          return [];
-        }
-      },
-      filterByLevel(logs: LogEntry[], filterLevel: LogLevel): LogEntry[] {
-        return logs.filter((l) => l.level === filterLevel);
-      },
-      filterByDateRange(logs: LogEntry[], startDate: Date, endDate: Date): LogEntry[] {
-        return logs.filter((l) => {
-          const date = new Date(l.timestamp);
-          return date >= startDate && date <= endDate;
-        });
-      },
-      clearLogs(category: string = 'app'): boolean {
-        const logFile = getLogFilePath(logsDir, category);
-        if (fs.existsSync(logFile)) {
-          fs.unlinkSync(logFile);
-          return true;
-        }
-        return false;
-      },
-      getLogsDirectory(): string {
-        return logsDir;
-      },
-      getLogLevel(): LogLevel {
-        return level;
-      },
-    };
-  },
-
-  /**
-   * Get singleton instance
-   */
-  getInstance(): LoggerInstance {
-    globalThis.__loggerInstance ??= this.create();
-    return globalThis.__loggerInstance;
-  },
-
-  // Static-like methods for convenience
-  debug(message: string, data?: Record<string, unknown>, category?: string): void {
-    this.getInstance().debug(message, data, category);
-  },
-  info(message: string, data?: Record<string, unknown>, category?: string): void {
-    this.getInstance().info(message, data, category);
-  },
-  warn(message: string, data?: Record<string, unknown>, category?: string): void {
-    this.getInstance().warn(message, data, category);
-  },
-  error(message: string, data?: Record<string, unknown>, category?: string): void {
-    this.getInstance().error(message, data, category);
-  },
-});
-
-// Extend globalThis for singleton
-declare global {
-  var __loggerInstance: LoggerInstance | undefined;
-}
-
-export default Logger;