vyriy 0.3.8 → 0.4.0

package/commands/create/preset/ssr.js

@@ -0,0 +1,16 @@
+import { base } from './base.js';
+export const ssr = {
+    files: (options) => ({
+        ...base.files(options),
+    }),
+    ci: {
+        github: {
+            '.gitlab-ci.yml': 'code',
+        },
+    },
+    deploy: {
+        docker: {
+            Dockerfile: 'code',
+        },
+    },
+};

package/commands/create/preset/types.d.ts

@@ -0,0 +1,15 @@
+import type { PlanResult } from '../plan/types.js';
+export type FileMap = Record<string, string>;
+export type CiProvider = 'gitlab' | 'github';
+export type DeployProvider = 'aws' | 'docker';
+export type Preset = {
+    files: (options: PlanResult) => FileMap;
+    ci: Partial<Record<CiProvider, FileMap>>;
+    deploy: Partial<Record<DeployProvider, FileMap>>;
+};
+export type PresetKey = 'base' | 'library' | 'api' | 'ssr' | 'rest' | 'gql' | 'ssg' | 'spa' | 'mfe';
+export type Presets = Partial<Record<PresetKey, {
+    name: string;
+    description: string;
+    preset: Preset;
+}>>;

package/commands/create/prompt/conflict-strategy.d.ts

@@ -0,0 +1,5 @@
+export type ConflictStrategy = {
+    readonly overwrite: boolean;
+    readonly skipExisting: boolean;
+};
+export declare const conflictStrategy: () => Promise<ConflictStrategy | undefined>;

package/commands/create/prompt/conflict-strategy.js

@@ -0,0 +1,22 @@
+import { stdin, stdout } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+export const conflictStrategy = async () => {
+    console.log('\nWhat should Vyriy do?\n');
+    console.log('  1. overwrite existing files');
+    console.log('  2. skip existing files');
+    console.log('  3. abort');
+    const readline = createInterface({ input: stdin, output: stdout });
+    try {
+        const answer = (await readline.question('\nWhat should Vyriy do? (abort): ')).trim().toLowerCase();
+        if (answer === '1' || answer === 'overwrite') {
+            return { overwrite: true, skipExisting: false };
+        }
+        if (answer === '2' || answer === 'skip') {
+            return { overwrite: false, skipExisting: true };
+        }
+        return undefined;
+    }
+    finally {
+        readline.close();
+    }
+};

package/commands/create/prompt/index.d.ts

@@ -0,0 +1,7 @@
+export * from './conflict-strategy.js';
+export * from './prompt.js';
+export * from './provider.js';
+export * from './preset.js';
+export * from './resolve-option.js';
+export * from './scope.js';
+export type * from './types.js';

package/commands/create/prompt/index.js

@@ -0,0 +1,6 @@
+export * from './conflict-strategy.js';
+export * from './prompt.js';
+export * from './provider.js';
+export * from './preset.js';
+export * from './resolve-option.js';
+export * from './scope.js';

package/commands/create/prompt/preset.d.ts

@@ -0,0 +1,4 @@
+import { presets as appPreset } from '../preset/index.js';
+import type { PromptOutput, PromptQuestion } from './types.js';
+export type PresetName = keyof typeof appPreset;
+export declare const preset: (question: PromptQuestion, output: PromptOutput) => Promise<PresetName>;

package/commands/create/prompt/preset.js

@@ -0,0 +1,11 @@
+import { presets as appPreset } from '../preset/index.js';
+import { prompt } from './prompt.js';
+import { resolveOption } from './resolve-option.js';
+export const preset = async (question, output) => {
+    const defaultPreset = 'base';
+    const presetNames = Object.keys(appPreset);
+    output.write('\nProject preset:\n\n');
+    presetNames.forEach((presetName, index) => output.write(`  ${index + 1}. ${appPreset[presetName].name} - ${appPreset[presetName].description}\n`));
+    const presetValue = await prompt(question, '\nPreset number or name', defaultPreset);
+    return resolveOption(presetValue, presetNames, defaultPreset);
+};

package/commands/create/prompt/prompt.d.ts

@@ -0,0 +1,2 @@
+import type { Prompt } from '../plan/types.js';
+export declare const prompt: Prompt;

package/commands/create/prompt/prompt.js

@@ -0,0 +1,4 @@
+export const prompt = async (question, label, defaultValue) => {
+    const answer = (await question(`${label} (${defaultValue}): `)).trim();
+    return answer || defaultValue;
+};

package/commands/create/prompt/provider.d.ts

@@ -0,0 +1,2 @@
+import type { PromptOutput, PromptQuestion } from './types.js';
+export declare const provider: <OptionName extends string>(question: PromptQuestion, output: PromptOutput, label: string, options: Partial<Record<OptionName, unknown>>) => Promise<OptionName | undefined>;

package/commands/create/prompt/provider.js

@@ -0,0 +1,13 @@
+import { prompt } from './prompt.js';
+import { resolveOption } from './resolve-option.js';
+export const provider = async (question, output, label, options) => {
+    const optionNames = Object.keys(options);
+    const defaultOption = optionNames[0];
+    if (defaultOption === undefined) {
+        return undefined;
+    }
+    output.write(`\n${label}:\n\n`);
+    optionNames.forEach((optionName, index) => output.write(`  ${index + 1}. ${optionName}\n`));
+    const optionValue = await prompt(question, `\n${label} number or name`, defaultOption);
+    return resolveOption(optionValue, optionNames);
+};

package/commands/create/prompt/resolve-option.d.ts

@@ -0,0 +1,6 @@
+type ResolveOption = {
+    <OptionName extends string>(value: string, optionNames: readonly OptionName[], fallback: OptionName): OptionName;
+    <OptionName extends string>(value: string, optionNames: readonly OptionName[]): OptionName | undefined;
+};
+export declare const resolveOption: ResolveOption;
+export {};

package/commands/create/prompt/resolve-option.js

@@ -0,0 +1,8 @@
+export const resolveOption = (value, optionNames, fallback) => {
+    const normalizedValue = value.trim();
+    const numericValue = Number.parseInt(normalizedValue, 10);
+    if (Number.isInteger(numericValue)) {
+        return optionNames[numericValue - 1] ?? fallback;
+    }
+    return optionNames.find((optionName) => optionName === normalizedValue) ?? fallback;
+};

package/commands/create/prompt/scope.d.ts

@@ -0,0 +1,2 @@
+import type { PromptQuestion } from './types.js';
+export declare const scope: (question: PromptQuestion, preset: string, name: string) => Promise<string | undefined>;

package/commands/create/prompt/scope.js

@@ -0,0 +1,2 @@
+import { prompt } from './prompt.js';
+export const scope = async (question, preset, name) => preset === 'base' ? undefined : prompt(question, 'Package scope', `@${name}`);

package/commands/create/prompt/types.d.ts

@@ -0,0 +1,4 @@
+export type PromptQuestion = (query: string) => Promise<string>;
+export type PromptOutput = {
+    write: (chunk: string) => unknown;
+};

package/commands/dist.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const dist: Command;

package/commands/dist.js

@@ -0,0 +1,274 @@
+import { chmod, copyFile, readdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const DIST_DIR = 'dist';
+const AGENTS_FILE = 'AGENTS.md';
+const LICENSE_FILE = 'LICENSE';
+const PACKAGE_JSON_FILE = 'package.json';
+const PACKAGES_DIR = 'packages';
+const README_FILE = 'README.md';
+const toPosixPath = (value) => value.split(path.sep).join('/');
+const toPackagePath = (value) => {
+    const normalizedValue = toPosixPath(value);
+    return `./${normalizedValue.replace(/^\.\//, '')}`;
+};
+const hasFile = async (filePath) => {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const readJson = async (filePath) => {
+    const content = await readFile(filePath, 'utf8');
+    return JSON.parse(content);
+};
+const writeJson = async (filePath, value) => {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+const isEmptyJavaScriptContent = (content) => {
+    const normalizedContent = content.trim();
+    return normalizedContent.length === 0 || normalizedContent === 'export {};';
+};
+const exportTargetPattern = /^\s*export(?:\s+\*|\s+\{[^}]*\})\s+from\s+['"](\..+\.js)['"];?\s*$/;
+const getMissingExportTarget = async (file, line) => {
+    const exportTarget = exportTargetPattern.exec(line)?.[1];
+    if (!exportTarget) {
+        return undefined;
+    }
+    const exportTargetPath = path.resolve(path.dirname(file), exportTarget);
+    return (await hasFile(exportTargetPath)) ? undefined : exportTargetPath;
+};
+const readFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return readFiles(entryPath);
+        }
+        return entry.isFile() ? [entryPath] : [];
+    }));
+    return files.flat();
+};
+const getPackageMain = async (packageDirectory, packageJson, javaScriptFiles) => {
+    if (packageJson.main?.endsWith('.js')) {
+        const mainPath = packageJson.main.replace(/^\.\//, '');
+        if (await hasFile(path.join(packageDirectory, mainPath))) {
+            return toPosixPath(mainPath);
+        }
+    }
+    if (javaScriptFiles.includes('index.js')) {
+        return 'index.js';
+    }
+    return javaScriptFiles[0];
+};
+const createExportTarget = (javaScriptFile) => {
+    const packagePath = toPackagePath(javaScriptFile);
+    return {
+        types: packagePath.replace(/\.js$/, '.d.ts'),
+        import: packagePath,
+        default: packagePath,
+    };
+};
+const createExports = (mainFile, javaScriptFiles) => {
+    const exports = {
+        '.': createExportTarget(mainFile),
+    };
+    for (const javaScriptFile of javaScriptFiles) {
+        const packagePath = toPackagePath(javaScriptFile);
+        const extensionlessPackagePath = packagePath.replace(/\.js$/, '');
+        const target = createExportTarget(javaScriptFile);
+        exports[extensionlessPackagePath] = target;
+        exports[packagePath] = target;
+    }
+    return exports;
+};
+const createPackageRepository = (rootPackageJson, packageDirectory) => {
+    const rootRepository = rootPackageJson.repository;
+    if (!rootRepository) {
+        return undefined;
+    }
+    return {
+        ...rootRepository,
+        directory: toPosixPath(path.join(PACKAGES_DIR, path.basename(packageDirectory))),
+    };
+};
+const getJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    const javaScriptFiles = [];
+    for (const file of files) {
+        const relativeFile = toPosixPath(path.relative(packageDirectory, file));
+        const declarationFile = path.join(packageDirectory, relativeFile.replace(/\.js$/, '.d.ts'));
+        if (relativeFile.endsWith('.js') && !relativeFile.endsWith('.test.js') && (await hasFile(declarationFile))) {
+            javaScriptFiles.push(relativeFile);
+        }
+    }
+    return javaScriptFiles.sort((left, right) => left.localeCompare(right));
+};
+const removeEmptyJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (file.endsWith('.js') && isEmptyJavaScriptContent(await readFile(file, 'utf8'))) {
+            await unlink(file);
+        }
+    }
+};
+const removeMissingJavaScriptExports = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (!file.endsWith('.js')) {
+            continue;
+        }
+        const content = await readFile(file, 'utf8');
+        const lines = content.split('\n');
+        const retainedLines = [];
+        for (const line of lines) {
+            if (!(await getMissingExportTarget(file, line))) {
+                retainedLines.push(line);
+            }
+        }
+        if (retainedLines.length !== lines.length) {
+            await writeFile(file, retainedLines.join('\n'));
+        }
+    }
+};
+const copyReadme = async (packageDirectory) => {
+    const packageName = path.basename(packageDirectory);
+    const sourceReadmePath = path.join(PACKAGES_DIR, packageName, README_FILE);
+    if (await hasFile(sourceReadmePath)) {
+        await copyFile(sourceReadmePath, path.join(packageDirectory, README_FILE));
+    }
+};
+const resolveSourceAgentsPath = async (packageAgentsPath, sharedAgentsPath, rootAgentsPath) => {
+    if (await hasFile(packageAgentsPath)) {
+        return packageAgentsPath;
+    }
+    if (await hasFile(sharedAgentsPath)) {
+        return sharedAgentsPath;
+    }
+    return rootAgentsPath;
+};
+const copyAgents = async (packageDirectory, rootPackageJson) => {
+    const packageName = path.basename(packageDirectory);
+    const packageAgentsPath = path.join(PACKAGES_DIR, packageName, AGENTS_FILE);
+    const sharedAgentsPath = path.join(PACKAGES_DIR, AGENTS_FILE);
+    const rootAgentsPath = typeof rootPackageJson.agents === 'string' ? rootPackageJson.agents.replace(/^\.\//, '') : '';
+    const sourceAgentsPath = await resolveSourceAgentsPath(packageAgentsPath, sharedAgentsPath, rootAgentsPath);
+    if (await hasFile(sourceAgentsPath)) {
+        await copyFile(sourceAgentsPath, path.join(packageDirectory, AGENTS_FILE));
+        return true;
+    }
+    return false;
+};
+const copyLicense = async (packageDirectory) => {
+    if (await hasFile(LICENSE_FILE)) {
+        await copyFile(LICENSE_FILE, path.join(packageDirectory, LICENSE_FILE));
+    }
+};
+const getPackageBinFiles = (packageJson) => {
+    if (typeof packageJson.bin === 'string') {
+        return [packageJson.bin];
+    }
+    if (packageJson.bin && typeof packageJson.bin === 'object') {
+        return Object.values(packageJson.bin);
+    }
+    return [];
+};
+const makePackageBinsExecutable = async (packageDirectory, packageJson) => {
+    for (const binFile of getPackageBinFiles(packageJson)) {
+        const binFilePath = path.join(packageDirectory, binFile.replace(/^\.\//, ''));
+        if (await hasFile(binFilePath)) {
+            await chmod(binFilePath, 0o755);
+        }
+    }
+};
+const copyRootFile = async (fileName) => {
+    if (await hasFile(fileName)) {
+        await copyFile(fileName, path.join(DIST_DIR, fileName));
+    }
+};
+const distRootPackageJson = async () => {
+    const packageJson = await readJson(PACKAGE_JSON_FILE);
+    delete packageJson.agents;
+    delete packageJson.dependencies;
+    delete packageJson.packageManager;
+    delete packageJson.scripts;
+    delete packageJson.devDependencies;
+    await writeJson(path.join(DIST_DIR, PACKAGE_JSON_FILE), packageJson);
+};
+const distRoot = async () => {
+    await copyRootFile(README_FILE);
+    await copyRootFile(LICENSE_FILE);
+    await distRootPackageJson();
+};
+const syncPackageRuntimeMetadata = (packageJson, rootPackageJson) => {
+    if (packageJson.name !== 'vyriy') {
+        return;
+    }
+    packageJson.packageManager = rootPackageJson.packageManager;
+    packageJson.engines = rootPackageJson.engines;
+};
+const distPackage = async (packageJsonPath, rootPackageJson) => {
+    const packageDirectory = path.dirname(packageJsonPath);
+    const packageJson = await readJson(packageJsonPath);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    await removeMissingJavaScriptExports(packageDirectory);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    const javaScriptFiles = await getJavaScriptFiles(packageDirectory);
+    await copyLicense(packageDirectory);
+    await copyReadme(packageDirectory);
+    const hasAgents = await copyAgents(packageDirectory, rootPackageJson);
+    delete packageJson.private;
+    if (hasAgents && rootPackageJson.agents) {
+        packageJson.agents = toPackagePath(AGENTS_FILE);
+    }
+    else {
+        delete packageJson.agents;
+    }
+    if (rootPackageJson.license) {
+        packageJson.license = rootPackageJson.license;
+    }
+    else {
+        delete packageJson.license;
+    }
+    const repository = createPackageRepository(rootPackageJson, packageDirectory);
+    if (repository) {
+        packageJson.repository = repository;
+    }
+    else {
+        delete packageJson.repository;
+    }
+    syncPackageRuntimeMetadata(packageJson, rootPackageJson);
+    if (javaScriptFiles.length > 0) {
+        const mainFile = await getPackageMain(packageDirectory, packageJson, javaScriptFiles);
+        if (mainFile) {
+            packageJson.main = toPackagePath(mainFile);
+            packageJson.types = toPackagePath(mainFile).replace(/\.js$/, '.d.ts');
+            packageJson.exports = createExports(mainFile, javaScriptFiles);
+        }
+    }
+    await makePackageBinsExecutable(packageDirectory, packageJson);
+    await writeJson(packageJsonPath, packageJson);
+};
+export const dist = async () => {
+    const previousCwd = process.cwd();
+    try {
+        process.chdir(process.cwd());
+        const rootPackageJson = await readJson(PACKAGE_JSON_FILE);
+        await distRoot();
+        const entries = await readdir(DIST_DIR, { withFileTypes: true });
+        const packageJsonPaths = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(DIST_DIR, entry.name, 'package.json'))
+            .sort((left, right) => left.localeCompare(right));
+        for (const packageJsonPath of packageJsonPaths) {
+            if (await hasFile(packageJsonPath)) {
+                await distPackage(packageJsonPath, rootPackageJson);
+            }
+        }
+        return 0;
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+};

package/commands/help.d.ts

@@ -0,0 +1,3 @@
+import { Command } from './types.js';
+export declare const text = "Vyriy Project Master\n\nUsage:\n  vyriy [name]           Create a new Vyriy project\n  vyriy .                Initialize a new Vyriy project in the current directory\n  vyriy --help, -h       Show help\n  vyriy --version, -v    Show version\n  vyriy --check-env, -c  Check local environment\n  vyriy --dist, -d       Prepare dist package metadata without publishing to npm\n  vyriy --dry-run        Print checks and file plan without writing\n  vyriy --overwrite      Overwrite existing generated paths\n  vyriy --skip-existing  Leave existing generated paths untouched\n  vyriy --no-install     Create files without installing dependencies\n  vyriy --no-verify      Install dependencies without running checks\n\nExamples:\n  vyriy app\n  vyriy .\n  vyriy -d";
+export declare const help: Command;

package/commands/help.js

@@ -0,0 +1,24 @@
+export const text = `Vyriy Project Master
+
+Usage:
+  vyriy [name]           Create a new Vyriy project
+  vyriy .                Initialize a new Vyriy project in the current directory
+  vyriy --help, -h       Show help
+  vyriy --version, -v    Show version
+  vyriy --check-env, -c  Check local environment
+  vyriy --dist, -d       Prepare dist package metadata without publishing to npm
+  vyriy --dry-run        Print checks and file plan without writing
+  vyriy --overwrite      Overwrite existing generated paths
+  vyriy --skip-existing  Leave existing generated paths untouched
+  vyriy --no-install     Create files without installing dependencies
+  vyriy --no-verify      Install dependencies without running checks
+
+Examples:
+  vyriy app
+  vyriy .
+  vyriy -d`;
+export const help = async () => {
+    console.log(text);
+    await Promise.resolve();
+    return 0;
+};

package/commands/index.d.ts

@@ -0,0 +1,5 @@
+export * from './help.js';
+export * from './version.js';
+export * from './dist.js';
+export * from './check-env.js';
+export * from './create/index.js';

package/commands/index.js

@@ -0,0 +1,5 @@
+export * from './help.js';
+export * from './version.js';
+export * from './dist.js';
+export * from './check-env.js';
+export * from './create/index.js';

package/commands/types.d.ts

@@ -0,0 +1,45 @@
+export type Command = () => Promise<number>;
+export type Node = () => {
+    ok: boolean;
+    message: string;
+};
+export type Yarn = () => Promise<{
+    ok: boolean;
+    message: string;
+}>;
+export type CreateOptions = {
+    readonly directory: string;
+    readonly dryRun: boolean;
+    readonly overwrite: boolean;
+    readonly skipExisting: boolean;
+    readonly install: boolean;
+    readonly verify: boolean;
+};
+export type Create = (options: CreateOptions) => Promise<number>;
+export type ExportTarget = {
+    readonly default: string;
+    readonly import: string;
+    readonly types: string;
+};
+export type Repository = {
+    readonly directory?: string;
+    readonly type: string;
+    readonly url: string;
+};
+export type PackageJson = {
+    agents?: string;
+    bin?: string | Record<string, string>;
+    dependencies?: unknown;
+    engines?: unknown;
+    exports?: Record<string, ExportTarget>;
+    license?: string;
+    main?: string;
+    name?: string;
+    packageManager?: unknown;
+    private?: boolean;
+    repository?: Repository;
+    scripts?: unknown;
+    types?: string;
+    workspaces?: unknown;
+    [key: string]: unknown;
+};

package/commands/version.d.ts

@@ -0,0 +1,2 @@
+import { Command } from './types.js';
+export declare const version: Command;

package/commands/version.js

@@ -0,0 +1,6 @@
+import packageJson from '../package.json' with { type: 'json' };
+export const version = async () => {
+    console.log(packageJson.version);
+    await Promise.resolve();
+    return 0;
+};