vyriy 0.3.8 → 0.3.9

package/README.md

@@ -34,6 +34,7 @@ vyriy new my-app
 vyriy .
 vyriy init
 vyriy doctor
+vyriy publish
 vyriy --dry-run
 vyriy --yes
 vyriy --no-install
@@ -79,6 +80,12 @@ Current checks:
 
 Node.js is fatal when unsupported. Yarn and Git are warnings so generation can continue without silently installing tools or initializing Git.
 
+### `vyriy publish`
+
+Prepares compiled `dist` package metadata for publishing without running `npm publish`.
+
+Use it after TypeScript emits package files into `dist`, for example from a `build:dist` script.
+
 ## Flags
 
 ### `--dry-run`

package/cli/args/args.js

@@ -32,6 +32,8 @@ export const parseArgs = (args) => {
             return { type: 'init', ...options };
         case 'doctor':
             return { type: 'doctor' };
+        case 'publish':
+            return { type: 'publish' };
         default:
             return { type: 'unknown', command };
     }

package/cli/args/types.d.ts

@@ -16,7 +16,7 @@ export type VyriyCliCommand = {
     readonly verify: boolean;
     readonly skipExisting: boolean;
 } | {
-    readonly type: 'doctor' | 'help' | 'version';
+    readonly type: 'doctor' | 'help' | 'publish' | 'version';
 } | {
     readonly type: 'unknown';
     readonly command: string;

package/cli/cli.js

@@ -1,6 +1,7 @@
 import { runDoctorCommand } from '../commands/doctor/index.js';
 import { runInitCommand } from '../commands/init/index.js';
 import { runNewCommand } from '../commands/new/index.js';
+import { runPublishCommand } from '../commands/publish/index.js';
 import packageJson from '../package.json' with { type: 'json' };
 import { parseArgs } from './args/index.js';
 const helpText = `Vyriy Project Master
@@ -10,6 +11,7 @@ Usage:
   vyriy init             Initialize the current directory
   vyriy .                Initialize the current directory
   vyriy doctor           Check local environment
+  vyriy publish          Prepare dist package metadata without publishing to npm
   vyriy --yes, -y        Use defaults where possible (empty preset)
   vyriy --dry-run        Print checks and file plan without writing
   vyriy --overwrite      Overwrite existing generated paths
@@ -57,6 +59,9 @@ export const runVyriyCli = async (args = [], { output = console } = {}) => {
             code = result.code;
             break;
         }
+        case 'publish':
+            code = await runPublishCommand();
+            break;
         case 'help':
             output.log(helpText);
             break;

package/commands/publish/index.d.ts

@@ -0,0 +1,2 @@
+export * from './publish.js';
+export type * from './types.js';

package/commands/publish/index.js

@@ -0,0 +1 @@
+export * from './publish.js';

package/commands/publish/publish.d.ts

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

package/commands/publish/publish.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 publishRootPackageJson = 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 publishRoot = async () => {
+    await copyRootFile(README_FILE);
+    await copyRootFile(LICENSE_FILE);
+    await publishRootPackageJson();
+};
+const syncPackageRuntimeMetadata = (packageJson, rootPackageJson) => {
+    if (packageJson.name !== 'vyriy') {
+        return;
+    }
+    packageJson.packageManager = rootPackageJson.packageManager;
+    packageJson.engines = rootPackageJson.engines;
+};
+const publishPackage = 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 runPublishCommand = async ({ cwd = process.cwd() } = {}) => {
+    const previousCwd = process.cwd();
+    try {
+        process.chdir(cwd);
+        const rootPackageJson = await readJson(PACKAGE_JSON_FILE);
+        await publishRoot();
+        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 publishPackage(packageJsonPath, rootPackageJson);
+            }
+        }
+        return 0;
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+};

package/commands/publish/types.d.ts

@@ -0,0 +1,31 @@
+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;
+};
+export type RunPublishCommandOptions = {
+    readonly cwd?: string;
+};
+export type RunPublishCommand = (options?: RunPublishCommandOptions) => Promise<number>;

package/index.d.ts

@@ -2,6 +2,7 @@ export * from './cli/index.js';
 export * from './commands/doctor/index.js';
 export * from './commands/init/index.js';
 export * from './commands/new/index.js';
+export * from './commands/publish/index.js';
 export * from './checks/yarn/index.js';
 export * from './doctor/index.js';
 export * from './file-plan/index.js';

package/index.js

@@ -2,6 +2,7 @@ export * from './cli/index.js';
 export * from './commands/doctor/index.js';
 export * from './commands/init/index.js';
 export * from './commands/new/index.js';
+export * from './commands/publish/index.js';
 export * from './checks/yarn/index.js';
 export * from './doctor/index.js';
 export * from './file-plan/index.js';

package/package.json

@@ -1,10 +1,74 @@
 {
   "name": "vyriy",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Interactive project master for calm cloud-ready applications.",
   "type": "module",
   "main": "./index.js",
   "bin": "./bin/vyriy.js",
+  "peerDependencies": {
+    "@storybook/react-webpack5": "^10.4.0",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "cross-env": "^10.1.0",
+    "eslint": "^10.4.0",
+    "husky": "^9.1.7",
+    "jest": "^30.4.2",
+    "npm-run-all2": "^9.0.0",
+    "prettier": "^3.8.3",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "rimraf": "^6.1.3",
+    "storybook": "^10.4.0",
+    "stylelint": "^17.12.0",
+    "typescript": "^6.0.3"
+  },
+  "peerDependenciesMeta": {
+    "@storybook/react-webpack5": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "@types/react-dom": {
+      "optional": true
+    },
+    "cross-env": {
+      "optional": true
+    },
+    "eslint": {
+      "optional": true
+    },
+    "husky": {
+      "optional": true
+    },
+    "jest": {
+      "optional": true
+    },
+    "npm-run-all2": {
+      "optional": true
+    },
+    "prettier": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "rimraf": {
+      "optional": true
+    },
+    "storybook": {
+      "optional": true
+    },
+    "stylelint": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
   "agents": "./AGENTS.md",
   "license": "MIT",
   "repository": {
@@ -12,6 +76,10 @@
     "url": "https://github.com/evheniy/vyriy",
     "directory": "packages/vyriy"
   },
+  "packageManager": "yarn@4.15.0",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "types": "./index.d.ts",
   "exports": {
     ".": {
@@ -169,6 +237,26 @@
       "import": "./commands/new/new.js",
       "default": "./commands/new/new.js"
     },
+    "./commands/publish/index": {
+      "types": "./commands/publish/index.d.ts",
+      "import": "./commands/publish/index.js",
+      "default": "./commands/publish/index.js"
+    },
+    "./commands/publish/index.js": {
+      "types": "./commands/publish/index.d.ts",
+      "import": "./commands/publish/index.js",
+      "default": "./commands/publish/index.js"
+    },
+    "./commands/publish/publish": {
+      "types": "./commands/publish/publish.d.ts",
+      "import": "./commands/publish/publish.js",
+      "default": "./commands/publish/publish.js"
+    },
+    "./commands/publish/publish.js": {
+      "types": "./commands/publish/publish.d.ts",
+      "import": "./commands/publish/publish.js",
+      "default": "./commands/publish/publish.js"
+    },
     "./doctor/checkCorepack": {
       "types": "./doctor/checkCorepack.d.ts",
       "import": "./doctor/checkCorepack.js",
@@ -299,6 +387,26 @@
       "import": "./presets/agentsTemplate.js",
       "default": "./presets/agentsTemplate.js"
     },
+    "./presets/base/createBaseFiles": {
+      "types": "./presets/base/createBaseFiles.d.ts",
+      "import": "./presets/base/createBaseFiles.js",
+      "default": "./presets/base/createBaseFiles.js"
+    },
+    "./presets/base/createBaseFiles.js": {
+      "types": "./presets/base/createBaseFiles.d.ts",
+      "import": "./presets/base/createBaseFiles.js",
+      "default": "./presets/base/createBaseFiles.js"
+    },
+    "./presets/config": {
+      "types": "./presets/config.d.ts",
+      "import": "./presets/config.js",
+      "default": "./presets/config.js"
+    },
+    "./presets/config.js": {
+      "types": "./presets/config.d.ts",
+      "import": "./presets/config.js",
+      "default": "./presets/config.js"
+    },
     "./presets/createProjectFiles": {
       "types": "./presets/createProjectFiles.d.ts",
       "import": "./presets/createProjectFiles.js",
@@ -319,6 +427,46 @@
       "import": "./presets/index.js",
       "default": "./presets/index.js"
     },
+    "./presets/library/createLibraryUiFiles": {
+      "types": "./presets/library/createLibraryUiFiles.d.ts",
+      "import": "./presets/library/createLibraryUiFiles.js",
+      "default": "./presets/library/createLibraryUiFiles.js"
+    },
+    "./presets/library/createLibraryUiFiles.js": {
+      "types": "./presets/library/createLibraryUiFiles.d.ts",
+      "import": "./presets/library/createLibraryUiFiles.js",
+      "default": "./presets/library/createLibraryUiFiles.js"
+    },
+    "./presets/packages/createPackageFiles": {
+      "types": "./presets/packages/createPackageFiles.d.ts",
+      "import": "./presets/packages/createPackageFiles.js",
+      "default": "./presets/packages/createPackageFiles.js"
+    },
+    "./presets/packages/createPackageFiles.js": {
+      "types": "./presets/packages/createPackageFiles.d.ts",
+      "import": "./presets/packages/createPackageFiles.js",
+      "default": "./presets/packages/createPackageFiles.js"
+    },
+    "./presets/packages/createPackageManifest": {
+      "types": "./presets/packages/createPackageManifest.d.ts",
+      "import": "./presets/packages/createPackageManifest.js",
+      "default": "./presets/packages/createPackageManifest.js"
+    },
+    "./presets/packages/createPackageManifest.js": {
+      "types": "./presets/packages/createPackageManifest.d.ts",
+      "import": "./presets/packages/createPackageManifest.js",
+      "default": "./presets/packages/createPackageManifest.js"
+    },
+    "./presets/workspaces/createWorkspaceFiles": {
+      "types": "./presets/workspaces/createWorkspaceFiles.d.ts",
+      "import": "./presets/workspaces/createWorkspaceFiles.js",
+      "default": "./presets/workspaces/createWorkspaceFiles.js"
+    },
+    "./presets/workspaces/createWorkspaceFiles.js": {
+      "types": "./presets/workspaces/createWorkspaceFiles.d.ts",
+      "import": "./presets/workspaces/createWorkspaceFiles.js",
+      "default": "./presets/workspaces/createWorkspaceFiles.js"
+    },
     "./project-plan/api/api": {
       "types": "./project-plan/api/api.d.ts",
       "import": "./project-plan/api/api.js",

package/presets/base/createBaseFiles.d.ts

@@ -0,0 +1,3 @@
+import { ProjectFile } from '../../file-plan/index.js';
+import type { VyriyProjectPlan } from '../../project-plan/index.js';
+export declare const createBaseFiles: (plan: VyriyProjectPlan) => ProjectFile[];