@zintrust/core 0.1.27 → 0.1.28

package/src/cli/commands/NewCommand.js

@@ -1,408 +0,0 @@
-import { BaseCommand } from '../BaseCommand.js';
-import { PromptHelper } from '../PromptHelper.js';
-import { GovernanceScaffolder } from '../scaffolding/GovernanceScaffolder.js';
-import { ProjectScaffolder } from '../scaffolding/ProjectScaffolder.js';
-import { SpawnUtil } from '../utils/spawn.js';
-import { readEnvString } from '../../common/ExternalServiceUtils.js';
-import { extractErrorMessage, resolvePackageManager } from '../../common/index.js';
-import { appConfig } from '../../config/app.js';
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import { execFileSync } from '../../node-singletons/child-process.js';
-import * as path from '../../node-singletons/path.js';
-import chalk from 'chalk';
-const getGitBinary = () => 'git';
-const checkGitInstalled = () => {
-    try {
-        execFileSync(getGitBinary(), ['--version'], { stdio: 'ignore', env: appConfig.getSafeEnv() });
-        return true;
-    }
-    catch (error) {
-        ErrorFactory.createCliError('Git check failed', error);
-        return false;
-    }
-};
-const initializeGitRepo = (projectPath, log) => {
-    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, key, fallback) => {
-    const value = options[key];
-    return typeof value === 'string' && value !== '' ? value : fallback;
-};
-const getBooleanOption = (options, key, fallback) => {
-    const value = options[key];
-    return typeof value === 'boolean' ? value : fallback;
-};
-const getProjectDefaults = (name, options) => {
-    const template = getStringOption(options, 'template', 'basic');
-    const normalizeDatabase = (value) => {
-        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) => ({
-    template: config.template,
-    database: config.database,
-    port: config.port,
-    author: config.author,
-    description: config.description,
-});
-const getQuestions = (name, defaults) => {
-    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) => {
-                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, answers) => {
-    const template = typeof answers['template'] === 'string'
-        ? answers['template']
-        : defaults.template;
-    const database = typeof answers['database'] === 'string'
-        ? answers['database']
-        : 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, options) => {
-    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) => {
-    if (typeof result !== 'object' || result === null)
-        return false;
-    const maybe = result;
-    return maybe.success === false;
-};
-const promptForPackageManager = async (defaultPm) => {
-    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'] ?? null;
-};
-const installDependencies = async (projectPath, log, packageManager, force = false) => {
-    // 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`);
-    }
-};
-const addOptions = (command) => {
-    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) => {
-    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) => {
-    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, options, command) => {
-    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, command, target) => {
-    if (options['git'] !== false) {
-        command.initializeGit(target.projectPath);
-    }
-};
-const maybeInstallDependencies = async (options, command, target) => {
-    if (options['install'] === false)
-        return;
-    const projectPath = target.projectPath;
-    let pm = options['packageManager'] ??
-        options['package-manager'];
-    // 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, command) => {
-    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 = () => {
-    // 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 = async () => {
-        // replaced below with NewCommand-aware execute implementation
-    };
-    const base = BaseCommand.create({
-        name: 'new',
-        description: 'Create a new ZinTrust project',
-        addOptions,
-        execute: async (options) => {
-            await executeImpl(options);
-        },
-    });
-    const commandInstance = {
-        ...base,
-        promptForConfig: async (name, options) => {
-            const config = await promptForConfig(name, options);
-            return toConfigResult(config);
-        },
-        getSafeEnv: () => appConfig.getSafeEnv(),
-        getGitBinary: () => getGitBinary(),
-        getQuestions: (name, defaults) => {
-            const fullDefaults = {
-                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, options) => {
-            return commandInstance.promptForConfig(name, options);
-        },
-        runScaffolding: async (basePath, name, config, overwrite) => {
-            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) => {
-            if (checkGitInstalled()) {
-                initializeGitRepo(projectPath, commandInstance);
-            }
-        },
-        promptForPackageManager: async (defaultPm) => {
-            return promptForPackageManager(defaultPm);
-        },
-        execute: async (options) => {
-            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() {
-        return createNewCommandInstance();
-    },
-});

package/src/cli/commands/NotificationWorkCommand.d.ts

@@ -1,10 +0,0 @@
-/**
- * Notification Work Command
- * Alias to work a notification queue.
- */
-import { type IBaseCommand } from '../BaseCommand';
-export declare const NotificationWorkCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-export default NotificationWorkCommand;
-//# sourceMappingURL=NotificationWorkCommand.d.ts.map

package/src/cli/commands/NotificationWorkCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NotificationWorkCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/NotificationWorkCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAQtB,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/src/cli/commands/NotificationWorkCommand.js

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

package/src/cli/commands/PluginCommand.d.ts

@@ -1,9 +0,0 @@
-/**
- * Plugin Command
- * Manage framework plugins (install, uninstall, list)
- */
-import type { IBaseCommand } from '../BaseCommand';
-export declare const PluginCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-//# sourceMappingURL=PluginCommand.d.ts.map

package/src/cli/commands/PluginCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PluginCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PluginCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrE,eAAO,MAAM,aAAa;cACd,YAAY;EAuDtB,CAAC"}

package/src/cli/commands/PluginCommand.js

@@ -1,98 +0,0 @@
-/**
- * Plugin Command
- * Manage framework plugins (install, uninstall, list)
- */
-import { BaseCommand } from '../BaseCommand.js';
-import { Logger } from '../../config/logger.js';
-import { PluginManager } from '../../runtime/PluginManager.js';
-export const PluginCommand = Object.freeze({
-    create() {
-        return BaseCommand.create({
-            name: 'plugin',
-            description: 'Manage framework plugins',
-            addOptions: (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, options) => {
-                    await installPlugin(pluginId, options);
-                });
-                command
-                    .command('uninstall <pluginId>')
-                    .alias('un')
-                    .description('Uninstall a plugin')
-                    .action(async (pluginId) => {
-                    await uninstallPlugin(pluginId);
-                });
-            },
-            execute: async (options) => {
-                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() {
-    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, options) {
-    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) {
-    try {
-        await PluginManager.uninstall(pluginId);
-    }
-    catch (error) {
-        Logger.error(`Failed to uninstall plugin ${pluginId}`, error);
-        process.exit(1);
-    }
-}

package/src/cli/commands/PrepareCommand.d.ts

@@ -1,8 +0,0 @@
-/**
- * Prepare Command
- * Makes the local dist/ folder installable via `file:/.../dist`.
- * Usage: zintrust prepare
- */
-import type { IBaseCommand } from '../BaseCommand';
-export declare const PrepareCommand: IBaseCommand;
-//# sourceMappingURL=PrepareCommand.d.ts.map

package/src/cli/commands/PrepareCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrepareCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PrepareCommand.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAerD,eAAO,MAAM,cAAc,EA2CtB,YAAY,CAAC"}

package/src/cli/commands/PrepareCommand.js

@@ -1,51 +0,0 @@
-/**
- * Prepare Command
- * Makes the local dist/ folder installable via `file:/.../dist`.
- * Usage: zintrust prepare
- */
-import { DistPackager } from '../utils/DistPackager.js';
-import { SpawnUtil } from '../utils/spawn.js';
-import { resolveNpmPath } from '../../common/index.js';
-import { Logger } from '../../config/logger.js';
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import * as path from '../../node-singletons/path.js';
-import chalk from 'chalk';
-import { Command } from 'commander';
-export const PrepareCommand = {
-    name: 'prepare',
-    description: 'Prepare local dist/ for file: installs (simulate/fresh install workflow)',
-    getCommand() {
-        return new Command('prepare')
-            .description('Prepare local dist/ so it can be installed via file:/.../dist')
-            .option('--dist <path>', 'Dist folder path (default: ./dist)')
-            .option('--link', 'Also run `npm link` to expose zintrust/zin/z/zt on PATH (dev-only)')
-            .action(async (options) => {
-            try {
-                const distRel = typeof options.dist === 'string' && options.dist.trim() !== '' ? options.dist : 'dist';
-                const distPath = path.resolve(process.cwd(), distRel);
-                DistPackager.prepare(distPath, process.cwd());
-                Logger.info(chalk.green('✅ Dist prepared.'));
-                Logger.info('Docs roots:');
-                Logger.info(`- Production/new apps: ${chalk.cyan('dist/public')}`);
-                Logger.info(`- Framework dev:      ${chalk.cyan('docs-website/public')}`);
-                if (options.link === true) {
-                    Logger.info(chalk.bold('\nLinking CLI globally (npm link)...'));
-                    const npm = resolveNpmPath();
-                    const exitCode = await SpawnUtil.spawnAndWait({
-                        command: npm,
-                        args: ['link'],
-                        cwd: process.cwd(),
-                    });
-                    if (exitCode !== 0) {
-                        throw ErrorFactory.createCliError(`npm link exited with code ${exitCode}`);
-                    }
-                    Logger.info(chalk.green('✅ Linked. You can now run `zintrust` from your shell.'));
-                }
-            }
-            catch (error) {
-                Logger.error('Failed to prepare dist', error);
-                throw ErrorFactory.createCliError('Prepare failed', error);
-            }
-        });
-    },
-};

package/src/cli/commands/PublishCommand.d.ts

@@ -1,5 +0,0 @@
-import { type IBaseCommand } from '../BaseCommand';
-export declare const PublishCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-//# sourceMappingURL=PublishCommand.d.ts.map

package/src/cli/commands/PublishCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PublishCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PublishCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0DlE,eAAO,MAAM,cAAc;cACf,YAAY;EAmBtB,CAAC"}