@open-audio-stack/core 0.1.9 → 0.1.11

package/build/classes/ManagerLocal.d.ts

@@ -5,8 +5,14 @@ import { ConfigInterface } from '../types/Config.js';
 export declare class ManagerLocal extends Manager {
     protected typeDir: string;
     constructor(type: RegistryType, config: ConfigInterface);
-    scan(ext?: string): void;
+    create(): Promise<void>;
+    scan(ext?: string, installable?: boolean): void;
     export(dir: string, ext?: string): boolean;
     install(slug: string, version?: string): Promise<void | PackageVersion>;
+    installDependency(slug: string, version?: string, filePath?: string, type?: RegistryType): Promise<any>;
+    installDependencies(filePath?: string, type?: RegistryType): Promise<any>;
+    open(filePath?: string): void;
     uninstall(slug: string, version?: string): Promise<void | PackageVersion>;
+    uninstallDependency(slug: string, version?: string, filePath?: string, type?: RegistryType): Promise<any>;
+    uninstallDependencies(filePath?: string, type?: RegistryType): Promise<any>;
 }

package/build/classes/ManagerLocal.js

@@ -1,8 +1,8 @@
 import path from 'path';
 import { Package } from './Package.js';
 import { Manager } from './Manager.js';
-import { archiveExtract, dirCreate, dirDelete, dirEmpty, dirRead, fileCreate, fileCreateJson, fileCreateYaml, fileExists, fileHash, fileOpen, fileReadJson, fileReadYaml, filesMove, isAdmin, runCliAsAdmin, } from '../helpers/file.js';
-import { pathGetSlug, pathGetVersion } from '../helpers/utils.js';
+import { archiveExtract, dirCreate, dirDelete, dirEmpty, dirRead, fileCreate, fileCreateJson, fileCreateYaml, fileExists, fileHash, fileInstall, fileOpen, fileReadJson, fileReadYaml, filesMove, isAdmin, runCliAsAdmin, } from '../helpers/file.js';
+import { isValidVersion, pathGetSlug, pathGetVersion, toSlug } from '../helpers/utils.js';
 import { commandExists, getArchitecture, getSystem, isTests } from '../helpers/utilsLocal.js';
 import { apiBuffer } from '../helpers/api.js';
 import { FileType } from '../types/FileType.js';
@@ -12,7 +12,14 @@ import { ConfigLocal } from './ConfigLocal.js';
 import { packageCompatibleFiles } from '../helpers/package.js';
 import { presetFormatDir } from '../types/PresetFormat.js';
 import { projectFormatDir } from '../types/ProjectFormat.js';
-import { FileFormat, SystemType } from '../index-browser.js';
+import { FileFormat } from '../types/FileFormat.js';
+import { licenses } from '../types/License.js';
+import { pluginTypes } from '../types/PluginType.js';
+import { presetTypes } from '../types/PresetType.js';
+import { projectTypes } from '../types/ProjectType.js';
+import { SystemType } from '../types/SystemType.js';
+import { packageLoadFile, packageSaveFile } from '../helpers/packageLocal.js';
+import inquirer from 'inquirer';
 export class ManagerLocal extends Manager {
     typeDir;
     constructor(type, config) {
@@ -21,12 +28,97 @@ export class ManagerLocal extends Manager {
         this.config = new ConfigLocal(configPath, config);
         this.typeDir = this.config.get(`${type}Dir`);
     }
-    scan(ext = 'json') {
+    async create() {
+        // TODO Rewrite this code after prototype is proven.
+        const pkgQuestions = [
+            {
+                name: 'org',
+                type: 'input',
+                message: 'Org id',
+                default: 'org-name',
+                validate: (value) => value === toSlug(value),
+            },
+            {
+                name: 'package',
+                type: 'input',
+                message: 'Package id',
+                default: 'package-name',
+                validate: (value) => value === toSlug(value),
+            },
+            {
+                name: 'version',
+                type: 'input',
+                message: 'Package version',
+                default: '1.0.0',
+                validate: (value) => isValidVersion(value),
+            },
+        ];
+        const pkgAnswers = await inquirer.prompt(pkgQuestions);
+        let types = pluginTypes;
+        if (this.type === RegistryType.Presets) {
+            types = presetTypes;
+        }
+        else if (this.type === RegistryType.Projects) {
+            types = projectTypes;
+        }
+        const pkgVersionQuestions = [
+            { name: 'name', type: 'input', message: 'Package name' },
+            { name: 'author', type: 'input', message: 'Author name' },
+            { name: 'description', type: 'input', message: 'Description' },
+            { name: 'license', type: 'list', message: 'License', choices: licenses },
+            { name: 'type', type: 'list', message: 'Type', choices: types },
+            {
+                name: 'tags',
+                type: 'input',
+                message: 'Tags (comma-separated)',
+                filter: (input) => input
+                    .split(',')
+                    .map(tag => tag.trim())
+                    .filter(tag => tag.length > 0),
+            },
+            {
+                name: 'url',
+                type: 'input',
+                message: 'Website url',
+                default: `https://github.com/${pkgAnswers.org}/${pkgAnswers.package}`,
+            },
+            {
+                name: 'audio',
+                type: 'input',
+                message: 'Audio preview url',
+                default: `https://open-audio-stack.github.io/open-audio-stack-registry/${this.type}/${pkgAnswers.org}/${pkgAnswers.package}/${pkgAnswers.package}.flac`,
+            },
+            {
+                name: 'image',
+                type: 'input',
+                message: 'Image preview url',
+                default: `https://open-audio-stack.github.io/open-audio-stack-registry/${this.type}/${pkgAnswers.org}/${pkgAnswers.package}/${pkgAnswers.package}.jpg`,
+            },
+            { name: 'date', type: 'input', message: 'Date released', default: new Date().toISOString() },
+            { name: 'changes', type: 'input', message: 'List of changes' },
+        ];
+        if (this.type === RegistryType.Projects) {
+            pkgVersionQuestions.push({ name: 'open', type: 'input', message: 'File to open' });
+        }
+        const pkgVersionAnswers = await inquirer.prompt(pkgVersionQuestions);
+        // TODO prompt for each file.
+        pkgVersionAnswers.files = [];
+        if (this.type === RegistryType.Presets || this.type === RegistryType.Projects) {
+            pkgVersionAnswers.plugins = [];
+        }
+        console.log(pkgVersionAnswers);
+        const pkg = new Package(`${pkgAnswers.org}/${pkgAnswers.package}`);
+        pkg.addVersion(pkgAnswers.version, pkgVersionAnswers);
+        console.log(JSON.stringify(pkg.getReport(), null, 2));
+        this.addPackage(pkg);
+    }
+    scan(ext = 'json', installable = true) {
         const filePaths = dirRead(`${this.typeDir}/**/index.${ext}`);
         filePaths.forEach((filePath) => {
             const subPath = filePath.replace(`${this.typeDir}/`, '');
             const pkgJson = ext === 'yaml' ? fileReadYaml(filePath) : fileReadJson(filePath);
-            pkgJson.installed = true;
+            if (installable)
+                pkgJson.installed = true;
             const pkg = new Package(pathGetSlug(subPath));
             const version = pathGetVersion(subPath);
             pkg.addVersion(version, pkgJson);
@@ -42,6 +134,7 @@ export class ManagerLocal extends Manager {
                 dirCreate(path.join(dir, pkgSlug, version));
                 saveFile(path.join(dir, pkgSlug, version, filename), pkgVersion);
             }
+            dirCreate(path.join(dir, pkgSlug, filename));
             saveFile(path.join(dir, pkgSlug, filename), pkg.toJSON());
             // TODO find a more elegant way to handle org exports.
             const pkgOrg = pkgSlug.split('/')[0];
@@ -105,9 +198,12 @@ export class ManagerLocal extends Manager {
             const hash = await fileHash(filePath);
             if (hash !== file.sha256)
                 return console.error(`Error: ${filePath} hash mismatch`);
-            // If installer, run the installer.
+            // If installer, run the installer headless (without the user interface).
             if (file.type === FileType.Installer) {
-                fileOpen(filePath);
+                if (isTests())
+                    fileOpen(filePath);
+                else
+                    fileInstall(filePath);
             }
             // If archive, extract the archive to temporary directory, then move individual files.
             if (file.type === FileType.Archive) {
@@ -130,6 +226,50 @@ export class ManagerLocal extends Manager {
         pkgVersion.installed = true;
         return pkgVersion;
     }
+    async installDependency(slug, version, filePath, type = RegistryType.Plugins) {
+        // Get dependency package information from registry.
+        const manager = new ManagerLocal(type, this.config.config);
+        await manager.sync();
+        const pkg = manager.getPackage(slug);
+        if (!pkg)
+            return console.error(`Package ${slug} not found in registry`);
+        const versionNum = version || pkg.latestVersion();
+        const pkgVersion = pkg?.getVersion(versionNum);
+        if (!pkgVersion)
+            return console.error(`Package ${slug} version ${versionNum} not found in registry`);
+        // Get local package file.
+        const pkgFile = packageLoadFile(filePath);
+        if (pkgFile[type] && pkgFile[type][slug] && pkgFile[type][slug] === versionNum) {
+            return console.error(`Package ${slug} version ${versionNum} is already a dependency`);
+        }
+        // Install dependency.
+        await manager.install(slug, version);
+        // Add dependency to local package file and save.
+        if (!pkgFile[type])
+            pkgFile[type] = {};
+        pkgFile[type][slug] = versionNum;
+        packageSaveFile(pkgFile, filePath);
+        pkgFile.installed = true;
+        return pkgFile;
+    }
+    async installDependencies(filePath, type = RegistryType.Plugins) {
+        // Loop through dependency packages and install each one.
+        const pkgFile = packageLoadFile(filePath);
+        const manager = new ManagerLocal(type, this.config.config);
+        await manager.sync();
+        for (const slug in pkgFile[type]) {
+            await manager.install(slug, pkgFile[type][slug]);
+        }
+        pkgFile.installed = true;
+        return pkgFile;
+    }
+    open(filePath) {
+        const pkgFile = packageLoadFile(filePath);
+        // If installer, run the installer.
+        if (pkgFile.open) {
+            fileOpen(pkgFile.open);
+        }
+    }
     async uninstall(slug, version) {
         // Get package information from registry.
         const pkg = this.getPackage(slug);
@@ -169,4 +309,34 @@ export class ManagerLocal extends Manager {
         delete pkgVersion.installed;
         return this.getPackage(slug)?.getVersion(versionNum);
     }
+    async uninstallDependency(slug, version, filePath, type = RegistryType.Plugins) {
+        // Get local package file.
+        const pkgFile = packageLoadFile(filePath);
+        if (!pkgFile[type])
+            return console.error(`Package ${type} is missing`);
+        if (!pkgFile[type][slug])
+            return console.error(`Package ${type} ${slug} is not a dependency`);
+        // Uninstall dependency.
+        const manager = new ManagerLocal(type, this.config.config);
+        await manager.sync();
+        await manager.uninstall(slug, version || pkgFile[type][slug]);
+        // Remove dependency from local package file and save.
+        if (!pkgFile[type])
+            pkgFile[type] = {};
+        delete pkgFile[type][slug];
+        packageSaveFile(pkgFile, filePath);
+        pkgFile.installed = true;
+        return pkgFile;
+    }
+    async uninstallDependencies(filePath, type = RegistryType.Plugins) {
+        // Loop through dependency packages and uninstall each one.
+        const pkgFile = packageLoadFile(filePath);
+        const manager = new ManagerLocal(type, this.config.config);
+        await manager.sync();
+        for (const slug in pkgFile[type]) {
+            await manager.uninstall(slug, pkgFile[type][slug]);
+        }
+        pkgFile.installed = true;
+        return pkgFile;
+    }
 }

package/build/classes/Package.d.ts

@@ -5,12 +5,12 @@ export declare class Package {
     version: string;
     versions: Map<string, PackageVersion>;
     constructor(slug: string, versions?: PackageVersions);
-    addVersion(version: string, details: PackageVersion): void;
-    removeVersion(version: string): void;
+    addVersion(num: string, version: PackageVersion): void;
+    removeVersion(num: string): void;
     getReport(): {
         [k: string]: PackageReport;
     };
-    getVersion(version: string): PackageVersion | undefined;
+    getVersion(num: string): PackageVersion | undefined;
     getVersionLatest(): PackageVersion | undefined;
     latestVersion(): string;
     toJSON(): {

package/build/classes/Package.js

@@ -14,33 +14,33 @@ export class Package {
         this.versions = versions ? new Map(Object.entries(versions)) : new Map();
         this.version = this.latestVersion();
     }
-    addVersion(version, details) {
-        if (this.versions.has(version))
+    addVersion(num, version) {
+        if (this.versions.has(num))
             return;
-        const errors = packageErrors(details);
-        const recs = packageRecommendations(details);
+        const errors = packageErrors(version);
+        const recs = packageRecommendations(version);
         const report = {
             ...(errors.length > 0 && { errors }),
             ...(recs.length > 0 && { recs }),
         };
         if (Object.keys(report).length > 0)
-            this.reports.set(version, report);
+            this.reports.set(num, report);
         if (errors.length > 0)
             return;
-        this.versions.set(version, details);
+        this.versions.set(num, version);
         this.version = this.latestVersion();
     }
-    removeVersion(version) {
-        if (!this.versions.has(version))
+    removeVersion(num) {
+        if (!this.versions.has(num))
             return;
-        this.versions.delete(version);
+        this.versions.delete(num);
         this.version = this.latestVersion();
     }
     getReport() {
         return Object.fromEntries(this.reports);
     }
-    getVersion(version) {
-        return this.versions.get(version);
+    getVersion(num) {
+        return this.versions.get(num);
     }
     getVersionLatest() {
         return this.versions.get(this.latestVersion());

package/build/classes/RegistryLocal.d.ts

@@ -4,5 +4,5 @@ export declare class RegistryLocal extends Registry {
     protected managers: Record<string, ManagerLocal>;
     constructor(name: string, url: string, version: string);
     export(dir: string, ext?: string): boolean;
-    scan(ext?: string): void;
+    scan(ext?: string, installable?: boolean): void;
 }

package/build/classes/RegistryLocal.js

@@ -16,9 +16,9 @@ export class RegistryLocal extends Registry {
         saveFile(path.join(dir, `index.${ext}`), this.toJSON());
         return true;
     }
-    scan(ext = 'json') {
+    scan(ext = 'json', installable = true) {
         for (const [, manager] of Object.entries(this.managers)) {
-            manager.scan(ext);
+            manager.scan(ext, installable);
         }
     }
 }

package/build/helpers/file.d.ts

@@ -28,6 +28,7 @@ export declare function fileDelete(filePath: string): boolean | void;
 export declare function fileExec(filePath: string): void;
 export declare function fileExists(filePath: string): boolean;
 export declare function fileHash(filePath: string, algorithm?: string): Promise<string>;
+export declare function fileInstall(filePath: string): Buffer;
 export declare function fileMove(filePath: string, newPath: string): void | boolean;
 export declare function filesMove(dirSource: string, dirTarget: string, dirSub: string, formatDir: Record<string, string>): string[];
 export declare function fileOpen(filePath: string): Buffer;

package/build/helpers/file.js

@@ -14,7 +14,6 @@ import { ZodIssueCode } from 'zod';
 import { SystemType } from '../types/SystemType.js';
 import { fileURLToPath } from 'url';
 import sudoPrompt from '@vscode/sudo-prompt';
-import { log } from './utils.js';
 import { getSystem } from './utilsLocal.js';
 export async function archiveExtract(filePath, dirPath) {
     console.log('⎋', dirPath);
@@ -168,6 +167,36 @@ export async function fileHash(filePath, algorithm = 'sha256') {
     await stream.pipeline(input, hash);
     return hash.digest('hex');
 }
+export function fileInstall(filePath) {
+    if (process.env.CI)
+        return Buffer.from('');
+    const ext = path.extname(filePath).toLowerCase();
+    let command = null;
+    switch (ext) {
+        case '.dmg':
+            command = `hdiutil attach -nobrowse "${filePath}" && sudo installer -pkg "$(find /Volumes -name '*.pkg' -maxdepth 2 | head -n 1)" -target / && hdiutil detach "$(find /Volumes -type d -maxdepth 1 -mindepth 1 | grep -v 'Macintosh HD')"`;
+            break;
+        case '.pkg':
+            command = `sudo installer -pkg "${filePath}" -target /`;
+            break;
+        case '.deb':
+            command = `sudo dpkg -i "${filePath}" || sudo apt-get install -f -y`;
+            break;
+        case '.rpm':
+            command = `sudo rpm -i --nodigest --nofiledigest --nosignature --force "${filePath}" || sudo dnf install -y "${filePath}" || sudo yum install -y "${filePath}"`;
+            break;
+        case '.exe':
+            command = `start /wait "" "${filePath}" /quiet /norestart`;
+            break;
+        case '.msi':
+            command = `msiexec /i "${filePath}" /quiet /norestart`;
+            break;
+        default:
+            throw new Error(`Unsupported file format: ${ext}`);
+    }
+    console.log('⎋', command);
+    return execSync(command, { stdio: 'inherit' });
+}
 export function fileMove(filePath, newPath) {
     if (fileExists(filePath)) {
         console.log('-', filePath);
@@ -187,11 +216,11 @@ export function filesMove(dirSource, dirTarget, dirSub, formatDir) {
         const fileExt = path.extname(fileSource).slice(1).toLowerCase();
         const fileExtTarget = formatDir[fileExt];
         // If this is not a supported file format, then ignore.
-        if (!fileExtTarget)
-            return;
+        if (fileExtTarget === undefined)
+            return console.error(`${fileSource} - ${fileExt} not mapped to a installation folder, skipping.`);
         const fileTarget = path.join(dirTarget, fileExtTarget, dirSub, path.basename(fileSource));
         if (fileExists(fileTarget))
-            return;
+            return console.error(`${fileSource} - ${fileTarget} already exists, skipping.`);
         dirCreate(path.dirname(fileTarget));
         fileMove(fileSource, fileTarget);
         filesMoved.push(fileTarget);
@@ -281,13 +310,13 @@ export function runCliAsAdmin(args) {
     return new Promise((resolve, reject) => {
         const filename = fileURLToPath(import.meta.url).replace('src/', 'build/');
         const dirPathClean = dirname(filename).replace('app.asar', 'app.asar.unpacked');
-        log(`node "${dirPathClean}${path.sep}helpers${path.sep}admin.js" ${args}`);
-        sudoPrompt.exec(`node "${dirPathClean}${path.sep}helpers${path.sep}admin.js" ${args}`, { name: 'Open Audio Stack' }, (error, stdout, stderr) => {
+        const script = path.join(dirPathClean, 'admin.js');
+        sudoPrompt.exec(`node "${script}" ${args}`, { name: 'Open Audio Stack' }, (error, stdout, stderr) => {
             if (stdout) {
-                log('runCliAsAdmin', stdout);
+                console.log('runCliAsAdmin', stdout);
             }
             if (stderr) {
-                log('runCliAsAdmin', stderr);
+                console.log('runCliAsAdmin', stderr);
             }
             if (error) {
                 reject(error);

package/build/helpers/package.d.ts

@@ -172,10 +172,10 @@ export declare const PackageVersionValidator: z.ZodObject<{
     }>;
     url: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    date: string;
     audio: string;
     author: string;
     changes: string;
-    date: string;
     description: string;
     files: {
         type: FileType;
@@ -197,10 +197,10 @@ export declare const PackageVersionValidator: z.ZodObject<{
     name: string;
     tags: string[];
 }, {
+    date: string;
     audio: string;
     author: string;
     changes: string;
-    date: string;
     description: string;
     files: {
         type: FileType;

package/build/helpers/package.js

@@ -8,6 +8,7 @@ import { PluginType } from '../types/PluginType.js';
 import { PresetType } from '../types/PresetType.js';
 import { ProjectType } from '../types/ProjectType.js';
 import { SystemType } from '../types/SystemType.js';
+import { pathGetExt } from './utils.js';
 export function packageCompatibleFiles(pkg, arch, sys, excludedFormats) {
     return pkg.files.filter((file) => {
         const archMatches = file.architectures.filter(architecture => {
@@ -16,7 +17,7 @@ export function packageCompatibleFiles(pkg, arch, sys, excludedFormats) {
         const sysMatches = file.systems.filter(system => {
             return sys.includes(system.type);
         });
-        const formatAllowed = excludedFormats && excludedFormats.includes(file.format) ? false : true;
+        const formatAllowed = excludedFormats && excludedFormats.includes(pathGetExt(file.url)) ? false : true;
         return archMatches.length && sysMatches.length && formatAllowed;
     });
 }
@@ -88,59 +89,85 @@ export function packageRecommendations(pkgVersion) {
             rec: 'should use the flac format',
         });
     }
-    const supportedArchitectures = {};
-    const supportedSystems = {};
-    const supportedFileFormats = {};
-    pkgVersion.files.forEach(file => {
-        file.architectures.forEach(architecture => {
-            supportedArchitectures[architecture] = true;
+    // Files
+    if (pkgVersion.files) {
+        const supportedArchitectures = {};
+        const supportedSystems = {};
+        const supportedFileFormats = {};
+        pkgVersion.files.forEach(file => {
+            file.architectures.forEach(architecture => {
+                supportedArchitectures[architecture] = true;
+            });
+            file.systems.forEach(system => {
+                supportedSystems[system.type] = true;
+            });
+            const ext = pathGetExt(file.url);
+            supportedFileFormats[ext] = true;
+            packageRecommendationsUrl(file, recs, 'url');
+            // Formats which do not support headless installation.
+            if (ext === FileFormat.AppImage)
+                recs.push({ field: 'url', rec: 'requires manual installation steps, consider .deb and .rpm instead' });
+            if (ext === FileFormat.AppleDiskImage)
+                recs.push({ field: 'url', rec: 'requires mounting step, consider .pkg instead' });
+            if (!Object.values(FileFormat).includes(ext))
+                recs.push({ field: 'url', rec: 'not a supported format' });
+            // Validate format is a supported installer format
+            const installerFormats = [
+                FileFormat.AppleDiskImage,
+                FileFormat.ApplePackage,
+                FileFormat.DebianPackage,
+                FileFormat.ExecutableInstaller,
+                FileFormat.RedHatPackage,
+                FileFormat.WindowsInstaller,
+            ];
+            if (file.type === FileType.Installer && !installerFormats.includes(ext))
+                recs.push({ field: 'type', rec: 'should match url field' });
         });
-        file.systems.forEach(system => {
-            supportedSystems[system.type] = true;
+        // Architectures
+        if (!supportedArchitectures.arm64)
+            recs.push({ field: 'architectures', rec: 'should support arm64' });
+        if (!supportedArchitectures.x64)
+            recs.push({ field: 'architectures', rec: 'should support x64' });
+        // Systems
+        if (!supportedSystems.linux)
+            recs.push({ field: 'systems', rec: 'should support Linux' });
+        if (!supportedSystems.mac)
+            recs.push({ field: 'systems', rec: 'should support Mac' });
+        if (!supportedSystems.win)
+            recs.push({ field: 'systems', rec: 'should support Windows' });
+    }
+    else {
+        recs.push({
+            field: 'files',
+            rec: 'is missing',
         });
-        supportedFileFormats[file.format] = true;
-        packageRecommendationsUrl(file, recs, 'url');
-        // Formats which do not support headless installation.
-        if (file.format === FileFormat.AppImage)
-            recs.push({ field: 'format', rec: 'requires manual installation steps, consider .deb and .rpm instead' });
-        if (file.format === FileFormat.AppleDiskImage)
-            recs.push({ field: 'format', rec: 'requires mounting step, consider .pkg instead' });
-        if (!file.url.includes(file.format))
-            recs.push({ field: 'format', rec: 'should match url field' });
-        // Validate format is a supported installer format
-        const installerFormats = [
-            FileFormat.AppleDiskImage,
-            FileFormat.ApplePackage,
-            FileFormat.DebianPackage,
-            FileFormat.ExecutableInstaller,
-            FileFormat.RedHatPackage,
-            FileFormat.WindowsInstaller,
-        ];
-        if (file.type === FileType.Installer && !installerFormats.includes(file.format))
-            recs.push({ field: 'type', rec: 'should match format field' });
-    });
-    // Architectures
-    if (!supportedArchitectures.arm64)
-        recs.push({ field: 'architectures', rec: 'should support arm64' });
-    if (!supportedArchitectures.x64)
-        recs.push({ field: 'architectures', rec: 'should support x64' });
-    // Systems
-    if (!supportedSystems.linux)
-        recs.push({ field: 'systems', rec: 'should support Linux' });
-    if (!supportedSystems.mac)
-        recs.push({ field: 'systems', rec: 'should support Mac' });
-    if (!supportedSystems.win)
-        recs.push({ field: 'systems', rec: 'should support Windows' });
+    }
     // Tags
-    const pluginTags = pkgVersion.tags.map(tag => tag.trim().toLowerCase());
-    if (pluginTags.length < 2)
-        recs.push({ field: 'tags', rec: 'should have more items' });
+    if (pkgVersion.tags) {
+        const pluginTags = pkgVersion.tags.map(tag => tag.trim().toLowerCase());
+        if (pluginTags.length < 2)
+            recs.push({ field: 'tags', rec: 'should have more items' });
+    }
+    else {
+        recs.push({
+            field: 'tags',
+            rec: 'is missing',
+        });
+    }
     // Licence
-    if (!Object.values(License).includes(pkgVersion.license)) {
-        recs.push({ field: 'license', rec: 'should be from the supported list' });
+    if (pkgVersion.license) {
+        if (!Object.values(License).includes(pkgVersion.license)) {
+            recs.push({ field: 'license', rec: 'should be from the supported list' });
+        }
+        else if (pkgVersion.license === License.Other) {
+            recs.push({ field: 'license', rec: 'should be more specific' });
+        }
     }
-    else if (pkgVersion.license === License.Other) {
-        recs.push({ field: 'license', rec: 'should be more specific' });
+    else {
+        recs.push({
+            field: 'license',
+            rec: 'is missing',
+        });
     }
     return recs;
 }

package/build/helpers/packageLocal.d.ts

@@ -0,0 +1,3 @@
+import { PackageVersion } from '../index-browser.js';
+export declare function packageLoadFile(filePath?: string): PackageVersion;
+export declare function packageSaveFile(pkgFile: PackageVersion, filePath?: string): PackageVersion;

package/build/helpers/packageLocal.js

@@ -0,0 +1,24 @@
+import path from 'path';
+import { fileCreateJson, fileReadJson } from './file.js';
+import { Package } from '../classes/Package.js';
+import { pathGetSlug, pathGetVersion } from './utils.js';
+export function packageLoadFile(filePath) {
+    // Read the file path and parse as json.
+    if (!filePath)
+        filePath = path.join('.', 'index.json');
+    const pkgFile = fileReadJson(filePath);
+    if (!pkgFile)
+        console.error(filePath, `not a valid json file`);
+    // Validate package json file structure, fields and values.
+    const pkg = new Package(pathGetSlug(filePath));
+    pkg.addVersion(pathGetVersion(filePath), pkgFile);
+    console.log(JSON.stringify(pkg.getReport()));
+    return pkgFile;
+}
+export function packageSaveFile(pkgFile, filePath) {
+    // Read the file path and parse as json.
+    if (!filePath)
+        filePath = path.join('.', 'index.json');
+    fileCreateJson(filePath, pkgFile);
+    return pkgFile;
+}

package/build/helpers/utils.d.ts

@@ -12,4 +12,6 @@ export declare function pathGetExt(path: string, sep?: string): string;
 export declare function pathGetFilename(path: string, sep?: string): string;
 export declare function pathGetSlug(path: string, sep?: string): string;
 export declare function pathGetVersion(path: string, sep?: string): string;
+export declare function toSlug(val: string): string;
 export declare function isValidSlug(slug: string): boolean;
+export declare function isValidVersion(version: string): boolean;

package/build/helpers/utils.js

@@ -1,5 +1,8 @@
 import chalk from 'chalk';
+import * as semver from 'semver';
+import slugify from 'slugify';
 let LOGGING_ENABLED = false;
+const URLSAFE_REGEX = /[^\w\s$*_+~.()'"!\-:@/]+/g;
 export function inputGetParts(input) {
     return input.split('@');
 }
@@ -62,6 +65,10 @@ export function pathGetVersion(path, sep = '/') {
     const parts = path.split(sep);
     return parts[parts.length - 2];
 }
+export function toSlug(val) {
+    // @ts-expect-error slugify library issue with ESM modules
+    return slugify(val, { lower: true, remove: URLSAFE_REGEX });
+}
 export function isValidSlug(slug) {
     let valid = true;
     // Must have exactly one slash.
@@ -70,5 +77,11 @@ export function isValidSlug(slug) {
     // Must be lowercase.
     if (slug !== slug.toLowerCase())
         valid = false;
+    // Must pass slugify conversion
+    if (slug !== toSlug(slug))
+        valid = false;
     return valid;
 }
+export function isValidVersion(version) {
+    return semver.valid(version) !== null;
+}

package/build/index-browser.js

@@ -17,6 +17,7 @@ export * from './helpers/config.js';
 // export * from './helpers/configLocal.js';
 // export * from './helpers/file.js';
 export * from './helpers/package.js';
+// export * from './helpers/packageLocal.js';
 export * from './helpers/registry.js';
 export * from './helpers/utils.js';
 // export * from './helpers/utilsLocal.js';

package/build/index.d.ts

@@ -10,6 +10,7 @@ export * from './helpers/config.js';
 export * from './helpers/configLocal.js';
 export * from './helpers/file.js';
 export * from './helpers/package.js';
+export * from './helpers/packageLocal.js';
 export * from './helpers/registry.js';
 export * from './helpers/utils.js';
 export * from './helpers/utilsLocal.js';

package/build/index.js

@@ -17,6 +17,7 @@ export * from './helpers/config.js';
 export * from './helpers/configLocal.js';
 export * from './helpers/file.js';
 export * from './helpers/package.js';
+export * from './helpers/packageLocal.js';
 export * from './helpers/registry.js';
 export * from './helpers/utils.js';
 export * from './helpers/utilsLocal.js';

package/build/types/File.d.ts

@@ -1,10 +1,8 @@
 import { Architecture } from './Architecture.js';
-import { FileFormat } from './FileFormat.js';
 import { FileType } from './FileType.js';
 import { System } from './System.js';
 export interface FileInterface {
     architectures: Architecture[];
-    format: FileFormat;
     sha256: string;
     size: number;
     systems: System[];

package/build/types/Preset.d.ts

@@ -2,9 +2,10 @@ import { FileInterface } from './File.js';
 import { PackageBase } from './Package.js';
 import { PresetFormat } from './PresetFormat.js';
 import { PresetType } from './PresetType.js';
+import { RegistryType } from './Registry.js';
 export interface PresetInterface extends PackageBase {
     files: PresetFile[];
-    plugins: PresetPlugins;
+    [RegistryType.Plugins]: PresetPlugins;
     type: PresetType;
 }
 export interface PresetFile extends FileInterface {

package/build/types/Preset.js

@@ -1 +1 @@
-export {};
+import { RegistryType } from './Registry.js';

package/build/types/Project.d.ts

@@ -2,9 +2,11 @@ import { FileInterface } from './File.js';
 import { PackageBase } from './Package.js';
 import { ProjectFormat } from './ProjectFormat.js';
 import { ProjectType } from './ProjectType.js';
+import { RegistryType } from './Registry.js';
 export interface ProjectInterface extends PackageBase {
     files: ProjectFile[];
-    plugins: ProjectPlugins;
+    open: string;
+    [RegistryType.Plugins]: ProjectPlugins;
     type: ProjectType;
 }
 export interface ProjectFile extends FileInterface {

package/build/types/Project.js

@@ -1 +1 @@
-export {};
+import { RegistryType } from './Registry.js';

package/build/types/ProjectFormat.js

@@ -13,19 +13,20 @@ export var ProjectFormat;
     ProjectFormat["Reaper"] = "rpp";
     ProjectFormat["Sonar"] = "cwp";
 })(ProjectFormat || (ProjectFormat = {}));
+// TODO don't organize projects by type, as this requires knwoing the type in advance for other operations.
 export const projectFormatDir = {
-    [ProjectFormat.AbletonLive]: 'Ableton',
-    [ProjectFormat.Bitwig]: 'Bitwig',
-    [ProjectFormat.Cubase]: 'Cubase',
-    [ProjectFormat.DAWproject]: 'DAWproject',
-    [ProjectFormat.FLStudio]: 'FLStudio',
-    [ProjectFormat.Garageband]: 'Garageband',
-    [ProjectFormat.Lmms]: 'Lmms',
-    [ProjectFormat.Logic]: 'Logic',
-    [ProjectFormat.Musescore]: 'Musescore',
-    [ProjectFormat.ProTools]: 'ProTools',
-    [ProjectFormat.Reaper]: 'Reaper',
-    [ProjectFormat.Sonar]: 'Sonar',
+    [ProjectFormat.AbletonLive]: '',
+    [ProjectFormat.Bitwig]: '',
+    [ProjectFormat.Cubase]: '',
+    [ProjectFormat.DAWproject]: '',
+    [ProjectFormat.FLStudio]: '',
+    [ProjectFormat.Garageband]: '',
+    [ProjectFormat.Lmms]: '',
+    [ProjectFormat.Logic]: '',
+    [ProjectFormat.Musescore]: '',
+    [ProjectFormat.ProTools]: '',
+    [ProjectFormat.Reaper]: '',
+    [ProjectFormat.Sonar]: '',
 };
 export const projectFormats = [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-audio-stack/core",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Open-source audio plugin management software",
   "type": "module",
   "main": "./build/index.js",
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "check": "npm run format && npm run lint && npm run build",
     "dev": "tsx ./src/index.ts",
     "format": "prettier . --write",
     "lint": "eslint .",
@@ -58,8 +59,10 @@
     "chalk": "^5.3.0",
     "fs-extra": "^11.2.0",
     "glob": "^11.0.0",
+    "inquirer": "^12.4.1",
     "js-yaml": "^4.1.0",
     "semver": "^7.6.3",
+    "slugify": "^1.6.6",
     "tar": "^7.4.3",
     "zod": "^3.23.8"
   },