@zintrust/core 0.1.28 → 0.1.30

package/src/cli/commands/NewCommand.ts

@@ -1,546 +0,0 @@
-/**
- * New Command - Project scaffolding CLI command
- * Handles creation of new ZinTrust projects
- */
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { PromptHelper } from '@cli/PromptHelper';
-import { GovernanceScaffolder } from '@cli/scaffolding/GovernanceScaffolder';
-import { ProjectScaffolder } from '@cli/scaffolding/ProjectScaffolder';
-import { SpawnUtil } from '@cli/utils/spawn';
-import { readEnvString } from '@common/ExternalServiceUtils';
-import { extractErrorMessage, resolvePackageManager } from '@common/index';
-import { appConfig } from '@config/app';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { execFileSync } from '@node-singletons/child-process';
-import * as path from '@node-singletons/path';
-import chalk from 'chalk';
-import type { Command } from 'commander';
-
-type TemplateType = 'basic' | 'api' | 'microservice' | 'fullstack';
-type DatabaseType = 'sqlite' | 'mysql' | 'postgresql' | 'mongodb' | 'd1-remote';
-
-interface NewProjectConfig {
-  name: string;
-  template: TemplateType;
-  database: DatabaseType;
-  port: number;
-  author: string;
-  description: string;
-  interactive: boolean;
-}
-
-interface NewProjectConfigResult {
-  template: TemplateType;
-  database: DatabaseType;
-  port: number;
-  author: string;
-  description: string;
-}
-
-type InquirerQuestion = Record<string, unknown>;
-
-type ResolvedProjectTarget = {
-  basePath: string;
-  name: string;
-  projectPath: string;
-  display: string;
-  cdPath: string;
-};
-
-const getGitBinary = (): string => 'git';
-
-const checkGitInstalled = (): boolean => {
-  try {
-    execFileSync(getGitBinary(), ['--version'], { stdio: 'ignore', env: appConfig.getSafeEnv() });
-    return true;
-  } catch (error) {
-    ErrorFactory.createCliError('Git check failed', error);
-    return false;
-  }
-};
-
-const initializeGitRepo = (projectPath: string, log: Pick<IBaseCommand, 'info' | 'warn'>): void => {
-  try {
-    const git = getGitBinary();
-    const env = appConfig.getSafeEnv();
-    execFileSync(git, ['init'], { cwd: projectPath, stdio: 'ignore', env });
-    execFileSync(git, ['add', '.'], { cwd: projectPath, stdio: 'ignore', env });
-    execFileSync(git, ['commit', '-m', 'Initial commit from ZinTrust'], {
-      cwd: projectPath,
-      stdio: 'ignore',
-      env,
-    });
-    log.info('✅ Git repository initialized');
-  } catch (error) {
-    ErrorFactory.createCliError('Git initialization failed', error);
-    log.warn('Could not initialize git repository');
-  }
-};
-
-const getStringOption = (options: CommandOptions, key: string, fallback: string): string => {
-  const value = options[key];
-  return typeof value === 'string' && value !== '' ? value : fallback;
-};
-
-const getBooleanOption = (options: CommandOptions, key: string, fallback: boolean): boolean => {
-  const value = options[key];
-  return typeof value === 'boolean' ? value : fallback;
-};
-
-const getProjectDefaults = (name: string, options: CommandOptions): NewProjectConfig => {
-  const template = getStringOption(options, 'template', 'basic') as TemplateType;
-  const normalizeDatabase = (value: string): DatabaseType => {
-    const v = value.trim();
-    if (v === 'd1-proxy') return 'd1-remote';
-    if (v === 'd1-remote') return 'd1-remote';
-    if (v === 'sqlite') return 'sqlite';
-    if (v === 'mysql') return 'mysql';
-    if (v === 'postgresql' || v === 'postgres') return 'postgresql';
-    if (v === 'mongodb') return 'mongodb';
-    return 'sqlite';
-  };
-
-  const database = normalizeDatabase(getStringOption(options, 'database', 'sqlite'));
-  const portRaw = getStringOption(options, 'port', '7777');
-  const portParsed = Number.parseInt(portRaw, 10);
-  const port = Number.isFinite(portParsed) && portParsed > 0 ? portParsed : 7777;
-
-  const author = getStringOption(options, 'author', '');
-  const description = getStringOption(options, 'description', `A new ZinTrust project: ${name}`);
-  const interactive = getBooleanOption(options, 'interactive', true);
-
-  return { name, template, database, port, author, description, interactive };
-};
-
-const toConfigResult = (config: NewProjectConfig): NewProjectConfigResult => ({
-  template: config.template,
-  database: config.database,
-  port: config.port,
-  author: config.author,
-  description: config.description,
-});
-
-const getQuestions = (name: string, defaults: NewProjectConfig): InquirerQuestion[] => {
-  return [
-    {
-      type: 'rawlist',
-      name: 'template',
-      message: 'Project template:',
-      choices: ['basic', 'api', 'microservice', 'fullstack'],
-      default: defaults.template,
-    },
-    {
-      type: 'rawlist',
-      name: 'database',
-      message: 'Database driver:',
-      choices: [
-        { name: 'sqlite — Local dev (file-based)', value: 'sqlite' },
-        { name: 'postgresql — Production-ready relational DB', value: 'postgresql' },
-        { name: 'mysql — Production-ready relational DB', value: 'mysql' },
-        { name: 'd1-proxy — Cloudflare D1 via HTTPS proxy', value: 'd1-remote' },
-        { name: 'mongodb — Document DB (may require additional setup)', value: 'mongodb' },
-      ],
-      default: defaults.database,
-    },
-
-    {
-      type: 'input',
-      name: 'port',
-      message: 'Default port number:',
-      default: String(defaults.port),
-      validate: (value: string): boolean => {
-        const port = Number.parseInt(value, 10);
-        return Number.isFinite(port) && port > 0 && port < 65536;
-      },
-    },
-    {
-      type: 'input',
-      name: 'author',
-      message: 'Project author:',
-      default: defaults.author,
-    },
-    {
-      type: 'input',
-      name: 'description',
-      message: 'Project description:',
-      default:
-        defaults.description === '' ? `A new ZinTrust project: ${name}` : defaults.description,
-    },
-  ];
-};
-
-const mergePromptAnswers = (
-  defaults: NewProjectConfig,
-  answers: Record<string, unknown>
-): NewProjectConfig => {
-  const template =
-    typeof answers['template'] === 'string'
-      ? (answers['template'] as TemplateType)
-      : defaults.template;
-  const database =
-    typeof answers['database'] === 'string'
-      ? (answers['database'] as DatabaseType)
-      : defaults.database;
-
-  let port = defaults.port;
-  const portAnswer = answers['port'];
-  if (typeof portAnswer === 'string') {
-    const parsed = Number.parseInt(portAnswer, 10);
-    if (Number.isFinite(parsed)) port = parsed;
-  } else if (typeof portAnswer === 'number') {
-    if (Number.isFinite(portAnswer)) port = portAnswer;
-  }
-
-  const author = typeof answers['author'] === 'string' ? answers['author'] : defaults.author;
-  const description =
-    typeof answers['description'] === 'string' ? answers['description'] : defaults.description;
-
-  return {
-    ...defaults,
-    template,
-    database,
-    port,
-    author,
-    description,
-  };
-};
-
-const promptForConfig = async (
-  name: string,
-  options: CommandOptions
-): Promise<NewProjectConfig> => {
-  const defaults = getProjectDefaults(name, options);
-  if (defaults.interactive === false) return defaults;
-
-  const questions = getQuestions(name, defaults);
-  const answers = await PromptHelper.prompt(questions);
-  return mergePromptAnswers(defaults, answers);
-};
-
-const isFailureResult = (result: unknown): result is { success: false; message?: string } => {
-  if (typeof result !== 'object' || result === null) return false;
-  const maybe = result as { success?: unknown; message?: unknown };
-  return maybe.success === false;
-};
-
-const promptForPackageManager = async (defaultPm: string): Promise<string | null> => {
-  const choices = [
-    { name: 'npm', value: 'npm' },
-    { name: 'yarn', value: 'yarn' },
-    { name: 'pnpm', value: 'pnpm' },
-    { name: 'bun', value: 'bun' },
-    { name: 'Skip installation', value: null },
-  ];
-
-  const answer = await PromptHelper.prompt([
-    {
-      type: 'rawlist',
-      name: 'packageManager',
-      message: 'Select package manager for dependency installation:',
-      choices,
-      default: defaultPm,
-    },
-  ]);
-
-  if (typeof answer !== 'object' || answer === null) return null;
-  return (answer['packageManager'] as string | null) ?? null;
-};
-
-const installDependencies = async (
-  projectPath: string,
-  log: Pick<IBaseCommand, 'info' | 'warn'>,
-  packageManager?: string,
-  force: boolean = false
-): Promise<void> => {
-  // Respect CI by default — avoid network installs in CI unless explicitly allowed
-  const ciRaw = readEnvString('CI').trim().toLowerCase();
-  const isCi = ciRaw !== '' && ciRaw !== '0' && ciRaw !== 'false';
-  const allowAuto = readEnvString('ZINTRUST_ALLOW_AUTO_INSTALL') === '1' || force;
-
-  if (isCi && !allowAuto) {
-    log.info('Skipping automatic dependency installation in CI environment.');
-    return;
-  }
-
-  if (packageManager === null) {
-    log.info('⏭️  Skipping dependency installation (not selected).');
-    return;
-  }
-
-  log.info('📦 Installing dependencies (this may take a minute)...');
-
-  const pm = packageManager ?? resolvePackageManager();
-  const args = ['install'];
-
-  try {
-    const exitCode = await SpawnUtil.spawnAndWait({ command: pm, args, cwd: projectPath });
-    if (exitCode !== 0) {
-      throw ErrorFactory.createCliError(`'${pm} install' failed with exit code ${exitCode}`);
-    }
-
-    log.info('✅ Dependencies installed successfully');
-  } catch (error) {
-    ErrorFactory.createCliError('Dependency installation failed', error);
-    log.warn(`Please run "${pm} install" manually in the project directory`);
-  }
-};
-
-interface INewCommand extends IBaseCommand {
-  promptForConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
-  getProjectConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
-  getQuestions(name: string, defaults: NewProjectConfigResult): InquirerQuestion[];
-  getSafeEnv(): NodeJS.ProcessEnv;
-  getGitBinary(): string;
-  runScaffolding(
-    basePath: string,
-    name: string,
-    config: NewProjectConfigResult,
-    overwrite?: boolean
-  ): Promise<unknown>;
-  initializeGit(projectPath: string): void;
-  promptForPackageManager(defaultPm: string): Promise<string | null>;
-}
-
-const addOptions = (command: Command): void => {
-  command.argument('<name>', 'Project name');
-  command.option(
-    '--template <type>',
-    'Project template (basic, api, microservice, fullstack)',
-    'basic'
-  );
-  command.option('--database <type>', 'Database driver (sqlite, mysql, postgresql)', 'sqlite');
-  command.option('--port <number>', 'Default port number', '7777');
-  command.option('--author <name>', 'Project author');
-  command.option('--description <text>', 'Project description');
-  command.option('--interactive', 'Run in interactive mode', true);
-  command.option('--no-interactive', 'Disable interactive mode');
-  command.option('--no-git', 'Skip git initialization');
-  command.option('--no-install', 'Skip dependency installation');
-  command.option('--install', 'Force dependency installation (useful to override CI defaults)');
-  command.option('--package-manager <manager>', 'Package manager to use (npm, yarn, pnpm)');
-  command.option('--governance', 'Install governance tooling (ESLint + architecture tests)', false);
-  command.option('--force', 'Overwrite existing directory');
-  command.option('--overwrite', 'Overwrite existing directory');
-};
-
-const resolveProjectName = async (options: CommandOptions): Promise<string> => {
-  const argName = options.args?.[0];
-  const projectName = argName ?? (await PromptHelper.projectName('my-zintrust-app', true));
-  if (!projectName) throw ErrorFactory.createCliError('Project name is required');
-  return projectName;
-};
-
-const resolveProjectTarget = async (options: CommandOptions): Promise<ResolvedProjectTarget> => {
-  const input = await resolveProjectName(options);
-
-  const isPathLike = input.includes('/') || input.includes('\\');
-  if (!isPathLike) {
-    return {
-      basePath: process.cwd(),
-      name: input,
-      projectPath: path.resolve(process.cwd(), input),
-      display: input,
-      cdPath: input,
-    };
-  }
-
-  const projectPath = path.resolve(process.cwd(), input);
-  const name = path.basename(projectPath);
-  const basePath = path.dirname(projectPath);
-  const cdPath = input.startsWith('/') ? projectPath : input;
-
-  return {
-    basePath,
-    name,
-    projectPath,
-    display: input,
-    cdPath,
-  };
-};
-
-const createProject = async (
-  target: ResolvedProjectTarget,
-  options: CommandOptions,
-  command: INewCommand
-): Promise<void> => {
-  const config = await command.getProjectConfig(target.name, options);
-  command.info(chalk.bold(`\n🚀 Creating new ZinTrust project in ${target.display}...\n`));
-
-  const overwrite = options['overwrite'] === true || options['force'] === true ? true : undefined;
-  const result = await command.runScaffolding(target.basePath, target.name, config, overwrite);
-
-  if (isFailureResult(result)) {
-    throw ErrorFactory.createCliError(result.message ?? 'Project scaffolding failed', result);
-  }
-
-  if (options['governance'] === true) {
-    const gov = await GovernanceScaffolder.scaffold(target.projectPath, {
-      writeEslintConfig: true,
-      writeArchTests: true,
-      install: false,
-    });
-
-    if (gov.success === false) {
-      throw ErrorFactory.createCliError(gov.message ?? 'Governance scaffolding failed', gov);
-    }
-  }
-};
-
-const maybeInitializeGit = (
-  options: CommandOptions,
-  command: INewCommand,
-  target: ResolvedProjectTarget
-): void => {
-  if (options['git'] !== false) {
-    command.initializeGit(target.projectPath);
-  }
-};
-
-const maybeInstallDependencies = async (
-  options: CommandOptions,
-  command: INewCommand,
-  target: ResolvedProjectTarget
-): Promise<string | undefined> => {
-  if (options['install'] === false) return;
-
-  const projectPath = target.projectPath;
-  let pm =
-    (options['packageManager'] as string | undefined) ??
-    (options['package-manager'] as string | undefined);
-
-  // If no package manager specified and not in non-interactive mode, prompt user
-  if (pm === undefined && options['interactive'] !== false && options['no-interactive'] !== true) {
-    const defaultPm = resolvePackageManager();
-    const selectedPm = await command.promptForPackageManager(defaultPm);
-    if (selectedPm === null) {
-      command.info('⏭️  Skipping dependency installation.');
-      pm = '__skip__'; // Signal to skip installation
-    } else {
-      pm = selectedPm;
-    }
-  }
-
-  const force = options['install'] === true;
-  if (pm === '__skip__') return;
-
-  const effectivePm = pm ?? resolvePackageManager();
-  await installDependencies(projectPath, command, pm, force);
-  return effectivePm;
-};
-
-const executeNewCommand = async (options: CommandOptions, command: INewCommand): Promise<void> => {
-  try {
-    const target = await resolveProjectTarget(options);
-
-    await createProject(target, options, command);
-
-    maybeInitializeGit(options, command, target);
-
-    await maybeInstallDependencies(options, command, target);
-
-    command.success(`\n✨ Project ${target.name} created successfully!`);
-
-    const runDevCmd = 'zin start';
-
-    command.info(`\nNext steps:\n  cd ${target.cdPath}\n  ${runDevCmd}\n`);
-  } catch (error) {
-    throw ErrorFactory.createCliError(
-      `Project creation failed: ${extractErrorMessage(error)}`,
-      error
-    );
-  }
-};
-
-const createNewCommandInstance = (): INewCommand => {
-  // BaseCommand.getCommand() closes over the execute callback passed at creation time.
-  // NewCommand needs its final implementation (which depends on the constructed instance),
-  // so we use a mutable indirection.
-  let executeImpl: (options: CommandOptions) => Promise<void> | void = async () => {
-    // replaced below with NewCommand-aware execute implementation
-  };
-
-  const base = BaseCommand.create({
-    name: 'new',
-    description: 'Create a new ZinTrust project',
-    addOptions,
-    execute: async (options: CommandOptions): Promise<void> => {
-      await executeImpl(options);
-    },
-  });
-
-  const commandInstance: INewCommand = {
-    ...base,
-    promptForConfig: async (
-      name: string,
-      options: CommandOptions
-    ): Promise<NewProjectConfigResult> => {
-      const config = await promptForConfig(name, options);
-      return toConfigResult(config);
-    },
-    getSafeEnv: (): NodeJS.ProcessEnv => appConfig.getSafeEnv(),
-    getGitBinary: (): string => getGitBinary(),
-    getQuestions: (name: string, defaults: NewProjectConfigResult): InquirerQuestion[] => {
-      const fullDefaults: NewProjectConfig = {
-        name,
-        template: defaults.template,
-        database: defaults.database,
-        port: defaults.port,
-        author: defaults.author,
-        description: defaults.description,
-        interactive: true,
-      };
-      return getQuestions(name, fullDefaults);
-    },
-    getProjectConfig: async (
-      name: string,
-      options: CommandOptions
-    ): Promise<NewProjectConfigResult> => {
-      return commandInstance.promptForConfig(name, options);
-    },
-    runScaffolding: async (
-      basePath: string,
-      name: string,
-      config: NewProjectConfigResult,
-      overwrite?: boolean
-    ): Promise<unknown> => {
-      return ProjectScaffolder.scaffold(basePath, {
-        name,
-        force: overwrite === true,
-        template: config.template,
-        database: config.database,
-        port: config.port,
-        author: config.author,
-        description: config.description,
-      });
-    },
-    initializeGit: (projectPath: string): void => {
-      if (checkGitInstalled()) {
-        initializeGitRepo(projectPath, commandInstance);
-      }
-    },
-    promptForPackageManager: async (defaultPm: string): Promise<string | null> => {
-      return promptForPackageManager(defaultPm);
-    },
-    execute: async (options: CommandOptions): Promise<void> => {
-      await executeNewCommand(options, commandInstance);
-    },
-  };
-
-  executeImpl = commandInstance.execute;
-
-  return commandInstance;
-};
-
-/**
- * New Command Factory
- * Sealed namespace for immutability
- */
-export const NewCommand = Object.freeze({
-  /**
-   * Create a new project command instance
-   */
-  create(): INewCommand {
-    return createNewCommandInstance();
-  },
-});

package/src/cli/commands/NotificationWorkCommand.ts

@@ -1,20 +0,0 @@
-/**
- * Notification Work Command
- * Alias to work a notification queue.
- */
-
-import { type IBaseCommand } from '@cli/BaseCommand';
-import { createKindWorkCommand } from '@cli/commands/createKindWorkCommand';
-
-export const NotificationWorkCommand = Object.freeze({
-  create(): IBaseCommand {
-    return createKindWorkCommand({
-      name: 'notification:work',
-      description: 'Work queued notifications',
-      kind: 'notification',
-      helpHint: 'zin notification:work --help',
-    });
-  },
-});
-
-export default NotificationWorkCommand;

package/src/cli/commands/PluginCommand.ts

@@ -1,112 +0,0 @@
-/**
- * Plugin Command
- * Manage framework plugins (install, uninstall, list)
- */
-
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { Logger } from '@config/logger';
-import { PluginManager } from '@runtime/PluginManager';
-import type { Command } from 'commander';
-
-export const PluginCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'plugin',
-      description: 'Manage framework plugins',
-      addOptions: (command: Command) => {
-        command.alias('p');
-
-        // Options for short syntax (zin p -i a:sqlite)
-        command.option('-i, --install <pluginId>', 'Install a plugin');
-        command.option('-u, --uninstall <pluginId>', 'Uninstall a plugin');
-        command.option('-l, --list', 'List available plugins');
-
-        command
-          .command('list')
-          .alias('ls')
-          .description('List available plugins')
-          .action(async () => {
-            await listPlugins();
-          });
-
-        command
-          .command('install <pluginId>')
-          .alias('i')
-          .description('Install a plugin')
-          .option('--package-manager <pm>', 'Specify package manager to use (npm|yarn|pnpm)')
-          .action(async (pluginId: string, options: Record<string, unknown>) => {
-            await installPlugin(pluginId, options);
-          });
-
-        command
-          .command('uninstall <pluginId>')
-          .alias('un')
-          .description('Uninstall a plugin')
-          .action(async (pluginId: string) => {
-            await uninstallPlugin(pluginId);
-          });
-      },
-      execute: async (options: CommandOptions) => {
-        const installId = options['install'];
-        const uninstallId = options['uninstall'];
-        const shouldList = options['list'];
-
-        if (typeof installId === 'string' && installId.length > 0) {
-          await installPlugin(installId);
-        } else if (typeof uninstallId === 'string' && uninstallId.length > 0) {
-          await uninstallPlugin(uninstallId);
-        } else if (shouldList === true) {
-          await listPlugins();
-        } else {
-          Logger.info('Use "plugin list", "plugin install <id>", or "plugin uninstall <id>"');
-          Logger.info('Shortcuts: "zin p -l", "zin p -i <id>", "zin p -u <id>"');
-        }
-      },
-    });
-  },
-});
-
-async function listPlugins(): Promise<void> {
-  const plugins = PluginManager.list();
-  Logger.info('Available Plugins:');
-
-  const pluginEntries = Object.entries(plugins);
-
-  const installedStatuses = await Promise.all(
-    pluginEntries.map(async ([id]) => PluginManager.isInstalled(id))
-  );
-
-  for (let i = 0; i < pluginEntries.length; i++) {
-    const [id, plugin] = pluginEntries[i];
-    const isInstalled = installedStatuses[i] ?? false;
-    const status = isInstalled ? '✓ Installed' : '- Available';
-    const aliases =
-      plugin.aliases !== undefined && plugin.aliases.length > 0
-        ? `(aliases: ${plugin.aliases.join(', ')})`
-        : '';
-    Logger.info(`  ${id.padEnd(20)} ${status.padEnd(15)} ${plugin.description} ${aliases}`);
-  }
-}
-
-async function installPlugin(pluginId: string, options?: Record<string, unknown>): Promise<void> {
-  try {
-    const pm =
-      typeof options?.['packageManager'] === 'string'
-        ? String(options?.['packageManager'])
-        : undefined;
-    await PluginManager.install(pluginId, { packageManager: pm });
-  } catch (error) {
-    Logger.error(`Failed to install plugin ${pluginId}`, error);
-    process.exit(1);
-  }
-}
-
-async function uninstallPlugin(pluginId: string): Promise<void> {
-  try {
-    await PluginManager.uninstall(pluginId);
-  } catch (error) {
-    Logger.error(`Failed to uninstall plugin ${pluginId}`, error);
-    process.exit(1);
-  }
-}