Move struct out of model folder.

src/structure/spec_model/module/File.struct.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Stats } from 'fs'
+import { Type, Module } from 'helios-distribution-types'
+import { resolve as resolveURL } from 'url'
+import { ModuleStructure } from './Module.struct'
+import { readdir, stat } from 'fs-extra'
+import { join, resolve, sep } from 'path'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+
+export class MiscFileStructure extends ModuleStructure {
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, 'files', baseUrl, minecraftVersion, Type.File)
+    }
+
+    public getLoggerName(): string {
+        return 'MiscFileStructure'
+    }
+
+    public async getSpecModel(): Promise<Module[]> {
+        if (this.resolvedModels == null) {
+            this.resolvedModels = await this.recursiveModuleScan(this.containerDirectory)
+        }
+
+        return this.resolvedModels
+    }
+
+    protected async recursiveModuleScan(dir: string): Promise<Module[]> {
+        let acc: Module[] = []
+        const subdirs = await readdir(dir)
+        for (const file of subdirs) {
+            const filePath = resolve(dir, file)
+            const stats = await stat(filePath)
+            if (stats.isDirectory()) {
+                acc = acc.concat(await this.recursiveModuleScan(filePath))
+            } else {
+                acc.push(await this.parseModule(file, filePath, stats))
+            }
+        }
+        return acc
+    }
+
+    protected async getModuleId(name: string, path: string): Promise<string> {
+        return name
+    }
+    protected async getModuleName(name: string, path: string): Promise<string> {
+        return name
+    }
+    protected async getModuleUrl(name: string, path: string, stats: Stats): Promise<string> {
+        return resolveURL(this.baseUrl, join(this.relativeRoot, ...path.substr(this.containerDirectory.length+1).split(sep)))
+    }
+    protected async getModulePath(name: string, path: string, stats: Stats): Promise<string | null> {
+        return path.substr(this.containerDirectory.length+1).replace(/\\/g, '/')
+    }
+
+}

src/structure/spec_model/module/ForgeMod.struct.ts

@@ -0,0 +1,61 @@
+import { Stats } from 'fs-extra'
+import { Type, Module } from 'helios-distribution-types'
+import { join } from 'path'
+import { resolve } from 'url'
+import { VersionSegmented } from '../../../util/VersionSegmented'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+import { ToggleableModuleStructure } from './ToggleableModule.struct'
+import { LibraryType } from '../../../model/claritas/ClaritasLibraryType'
+import { ClaritasException } from './Module.struct'
+
+export abstract class BaseForgeModStructure extends ToggleableModuleStructure implements VersionSegmented {
+
+    protected readonly EXAMPLE_MOD_ID = 'examplemod'
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, 'forgemods', baseUrl, minecraftVersion, Type.ForgeMod)
+    }
+
+    public async getSpecModel(): Promise<Module[]> {
+        // Sort by file name to allow control of load order.
+        return (await super.getSpecModel()).sort((a, b) => {
+            const aFileName = a.artifact.url.substring(a.artifact.url.lastIndexOf('/')+1)
+            const bFileName = b.artifact.url.substring(b.artifact.url.lastIndexOf('/')+1)
+            return aFileName.localeCompare(bFileName)
+        })
+    }
+
+    public abstract isForVersion(version: MinecraftVersion, libraryVersion: string): boolean
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModuleUrl(name: string, path: string, stats: Stats): Promise<string> {
+        return resolve(this.baseUrl, join(this.relativeRoot, this.getActiveNamespace(), name))
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModulePath(name: string, path: string, stats: Stats): Promise<string | null> {
+        return null
+    }
+
+    protected getClaritasExceptions(): ClaritasException[] {
+        return [{
+            exceptionName: 'optifine',
+            proxyMetadata: {
+                group: 'net.optifine'
+            }
+        }]
+    }
+
+    protected getClaritasType(): LibraryType {
+        return LibraryType.FORGE
+    }
+
+    protected discernResult(claritasValue: string | undefined, crudeInference: string): string {
+        return (claritasValue == null || claritasValue == '') ? crudeInference : claritasValue
+    }
+
+}

src/structure/spec_model/module/Library.struct.ts

@@ -0,0 +1,44 @@
+import { ModuleStructure } from './Module.struct'
+import { Type, TypeMetadata } from 'helios-distribution-types'
+import { Stats } from 'fs-extra'
+import { join } from 'path'
+import { resolve } from 'url'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+
+export class LibraryStructure extends ModuleStructure {
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, 'libraries', baseUrl, minecraftVersion, Type.Library, (name: string) => {
+            return name.toLowerCase().endsWith(TypeMetadata[this.type].defaultExtension!)
+        })
+    }
+
+    public getLoggerName(): string {
+        return 'LibraryStructure'
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModuleId(name: string, path: string): Promise<string> {
+        const inference = this.attemptCrudeInference(name)
+        return this.generateMavenIdentifier(this.getDefaultGroup(), inference.name, inference.version)
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModuleName(name: string, path: string): Promise<string> {
+        const inference = this.attemptCrudeInference(name)
+        return inference.name
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModuleUrl(name: string, path: string, stats: Stats): Promise<string> {
+        return resolve(this.baseUrl, join(this.relativeRoot, name))
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModulePath(name: string, path: string, stats: Stats): Promise<string | null> {
+        return null
+    }
+
+}

src/structure/spec_model/module/LiteMod.struct.ts

@@ -0,0 +1,101 @@
+import StreamZip from 'node-stream-zip'
+import { Stats } from 'fs-extra'
+import { Type } from 'helios-distribution-types'
+import { join } from 'path'
+import { resolve } from 'url'
+import { capitalize } from '../../../util/stringutils'
+import { LiteMod } from '../../../model/liteloader/litemod'
+import { ToggleableModuleStructure } from './ToggleableModule.struct'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+import { LibraryType } from '../../../model/claritas/ClaritasLibraryType'
+import { MetadataUtil } from '../../../util/MetadataUtil'
+
+export class LiteModStructure extends ToggleableModuleStructure {
+
+    private liteModMetadata: {[property: string]: LiteMod | undefined} = {}
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, 'litemods', baseUrl, minecraftVersion, Type.LiteMod)
+    }
+
+    public getLoggerName(): string {
+        return 'LiteModStructure'
+    }
+
+    protected async getModuleId(name: string, path: string): Promise<string> {
+        const liteModData = await this.getLiteModMetadata(name, path)
+        return this.generateMavenIdentifier(
+            MetadataUtil.completeGroupInference(this.getClaritasGroup(path), liteModData.name), liteModData.name, `${liteModData.version}-${liteModData.mcversion}`)
+    }
+    protected async getModuleName(name: string, path: string): Promise<string> {
+        return capitalize((await this.getLiteModMetadata(name, path)).name)
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModuleUrl(name: string, path: string, stats: Stats): Promise<string> {
+        return resolve(this.baseUrl, join(this.relativeRoot, this.getActiveNamespace(), name))
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async getModulePath(name: string, path: string, stats: Stats): Promise<string | null> {
+        return null
+    }
+
+    protected getClaritasType(): LibraryType {
+        return LibraryType.LITELOADER
+    }
+
+    private getLiteModMetadata(name: string, path: string): Promise<LiteMod> {
+        return new Promise((resolve, reject) => {
+            if (!Object.prototype.hasOwnProperty.call(this.liteModMetadata, name)) {
+
+                const zip = new StreamZip({
+                    file: path,
+                    storeEntries: true
+                })
+
+                zip.on('error', err => reject(err))
+                zip.on('ready', () => {
+                    try {
+                        const res = this.processZip(zip, name)
+                        zip.close()
+                        resolve(res)
+                        return
+                    } catch(err) {
+                        zip.close()
+                        reject(err)
+                        return
+                    }
+                })
+
+            } else {
+                resolve(this.liteModMetadata[name] as LiteMod)
+                return
+            }
+
+        })
+    }
+
+    private processZip(zip: StreamZip, name: string): LiteMod {
+
+        let raw: Buffer | undefined
+        try {
+            raw = zip.entryDataSync('litemod.json')
+        } catch(err) {
+            // ignored
+        }
+
+        if (raw) {
+            this.liteModMetadata[name] = JSON.parse(raw.toString()) as LiteMod
+        } else {
+            throw new Error(`Litemod ${name} does not contain litemod.json file.`)
+        }
+
+        return this.liteModMetadata[name] as LiteMod
+
+    }
+
+}

src/structure/spec_model/module/Module.struct.ts

@@ -0,0 +1,185 @@
+import { createHash } from 'crypto'
+import { lstat, pathExists, readdir, readFile, Stats } from 'fs-extra'
+import { Module, Type, TypeMetadata } from 'helios-distribution-types'
+import { resolve } from 'path'
+import { BaseModelStructure } from '../BaseModel.struct'
+import { LibraryType } from '../../../model/claritas/ClaritasLibraryType'
+import { ClaritasResult, ClaritasModuleMetadata } from '../../../model/claritas/ClaritasResult'
+import { ClaritasWrapper } from '../../../util/java/ClaritasWrapper'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+
+export interface ModuleCandidate {
+    file: string
+    filePath: string
+    stats: Stats
+}
+
+export interface ClaritasException {
+    exceptionName: string
+    proxyMetadata: ClaritasModuleMetadata
+}
+
+export abstract class ModuleStructure extends BaseModelStructure<Module> {
+
+    private readonly crudeRegex = /(.+?)-(.+).[jJ][aA][rR]/
+    protected readonly DEFAULT_VERSION = '0.0.0'
+
+    protected claritasResult!: ClaritasResult
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        structRoot: string,
+        baseUrl: string,
+        protected minecraftVersion: MinecraftVersion,
+        protected type: Type,
+        protected filter?: ((name: string, path: string, stats: Stats) => boolean)
+    ) {
+        super(absoluteRoot, relativeRoot, structRoot, baseUrl)
+    }
+
+    public async getSpecModel(): Promise<Module[]> {
+        if (this.resolvedModels == null) {
+            this.resolvedModels = await this._doModuleRetrieval(await this._doModuleDiscovery(this.containerDirectory))
+        }
+
+        return this.resolvedModels
+    }
+
+    protected getDefaultGroup(): string {
+        return `generated.${this.type.toLowerCase()}`
+    }
+
+    protected generateMavenIdentifier(group: string, id: string, version: string): string {
+        return `${group}:${id}:${version}@${TypeMetadata[this.type].defaultExtension}`
+    }
+
+    protected attemptCrudeInference(name: string): { name: string, version: string } {
+        const result = this.crudeRegex.exec(name)
+        if(result != null) {
+            return {
+                name: result[1],
+                version: result[2]
+            }
+        } else {
+            return {
+                name: name.substring(0, name.lastIndexOf('.')),
+                version: this.DEFAULT_VERSION
+            }
+        }
+    }
+
+    protected getClaritasGroup(path: string): string {
+        return this.claritasResult[path]?.group || this.getDefaultGroup()
+    }
+
+    protected getClaritasExceptions(): ClaritasException[] {
+        return []
+    }
+
+    protected getClaritasType(): LibraryType | null {
+        return null
+    }
+
+    protected async abstract getModuleId(name: string, path: string): Promise<string>
+    protected async abstract getModuleName(name: string, path: string): Promise<string>
+    protected async abstract getModuleUrl(name: string, path: string, stats: Stats): Promise<string>
+    protected async abstract getModulePath(name: string, path: string, stats: Stats): Promise<string | null>
+
+    protected async parseModule(file: string, filePath: string, stats: Stats): Promise<Module> {
+        const buf = await readFile(filePath)
+        const mdl: Module = {
+            id: await this.getModuleId(file, filePath),
+            name: await this.getModuleName(file, filePath),
+            type: this.type,
+            artifact: {
+                size: stats.size,
+                MD5: createHash('md5').update(buf).digest('hex'),
+                url: await this.getModuleUrl(file, filePath, stats)
+            }
+        }
+        const pth = await this.getModulePath(file, filePath, stats)
+        if (pth) {
+            mdl.artifact.path = pth
+        }
+        return mdl
+    }
+
+    protected async _doModuleDiscovery(scanDirectory: string): Promise<ModuleCandidate[]> {
+
+        const moduleCandidates: ModuleCandidate[] = []
+
+        if (await pathExists(scanDirectory)) {
+            const files = await readdir(scanDirectory)
+            for (const file of files) {
+                const filePath = resolve(scanDirectory, file)
+                const stats = await lstat(filePath)
+                if (stats.isFile()) {
+                    if(this.filter == null || this.filter(file, filePath, stats)) {
+                        moduleCandidates.push({file, filePath, stats})
+                    }
+                }
+            }
+        }
+
+        return moduleCandidates
+
+    }
+
+    protected async invokeClaritas(moduleCandidates: ModuleCandidate[]): Promise<void> {
+        if(this.getClaritasType() != null) {
+            const claritasExecutor = new ClaritasWrapper(this.absoluteRoot)
+
+            let claritasCandidates = moduleCandidates
+            const exceptionCandidates: [ModuleCandidate, ClaritasException][] = []
+            for(const exception of this.getClaritasExceptions()) {
+                const exceptionCandidate = moduleCandidates.find((value) => value.file.toLowerCase().indexOf(exception.exceptionName) > -1)
+                if(exceptionCandidate != null) {
+                    exceptionCandidates.push([exceptionCandidate, exception])
+                    claritasCandidates = claritasCandidates.filter((value) => value.file.toLowerCase().indexOf(exception.exceptionName) === -1)
+                }
+            }
+
+            this.claritasResult = await claritasExecutor.execute(
+                this.getClaritasType()!,
+                this.minecraftVersion,
+                claritasCandidates.map(entry => entry.filePath)
+            )
+
+            if(this.claritasResult == null) {
+                this.logger.error('Failed to process Claritas result!')
+            } else {
+                for(const [candidate, exception] of exceptionCandidates) {
+                    this.claritasResult[candidate.filePath] = exception.proxyMetadata
+                }
+            }
+        }
+    }
+
+    protected async _doModuleRetrieval(moduleCandidates: ModuleCandidate[], options?: {
+        preProcess?: (candidate: ModuleCandidate) => void
+        postProcess?: (module: Module) => void
+    }): Promise<Module[]> {
+
+        const accumulator: Module[] = []
+        
+        if(moduleCandidates.length > 0) {
+
+            // Invoke Claritas and attach result to class.
+            await this.invokeClaritas(moduleCandidates)
+    
+            // Process Modules
+            for(const candidate of moduleCandidates) {
+                options?.preProcess?.(candidate)
+                const mdl = await this.parseModule(candidate.file, candidate.filePath, candidate.stats)
+                options?.postProcess?.(mdl)
+                accumulator.push(mdl)
+            }
+
+        }
+        
+        return accumulator
+
+    }
+
+}

src/structure/spec_model/module/ToggleableModule.struct.ts

@@ -0,0 +1,82 @@
+import { ModuleStructure, ModuleCandidate } from './Module.struct'
+import { Type, Module } from 'helios-distribution-types'
+import { Stats, mkdirs } from 'fs-extra'
+import { resolve } from 'path'
+import { MinecraftVersion } from '../../../util/MinecraftVersion'
+
+export enum ToggleableNamespace {
+
+    REQUIRED = 'required',
+    OPTIONAL_ON = 'optionalon',
+    OPTIONAL_OFF = 'optionaloff'
+
+}
+
+export interface ToggleableModuleCandidate extends ModuleCandidate {
+    namespace: ToggleableNamespace
+}
+
+export abstract class ToggleableModuleStructure extends ModuleStructure {
+    
+    private activeNamespace: string | undefined
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        structRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion,
+        type: Type,
+        filter?: ((name: string, path: string, stats: Stats) => boolean)
+    ) {
+        super(absoluteRoot, relativeRoot, structRoot, baseUrl, minecraftVersion, type, filter)
+    }
+
+    public async init(): Promise<void> {
+        await super.init()
+        for(const namespace of Object.values(ToggleableNamespace)) {
+            await mkdirs(resolve(this.containerDirectory, namespace))
+        }
+    }
+
+    public async getSpecModel(): Promise<Module[]> {
+        if (this.resolvedModels == null) {
+
+            const moduleCandidates: ToggleableModuleCandidate[] = []
+            for(const value of Object.values(ToggleableNamespace)) {
+                moduleCandidates.push(...(await super._doModuleDiscovery(resolve(this.containerDirectory, value))).map(val => ({...val, namespace: value})))
+            }
+
+            this.resolvedModels = await this._doModuleRetrieval(moduleCandidates, {
+                preProcess: (candidate) => {
+                    this.activeNamespace = (candidate as ToggleableModuleCandidate).namespace
+                },
+                postProcess: (module) => {
+                    this.getNamespaceMapper(this.activeNamespace as ToggleableNamespace)(module)
+                }
+            })
+
+            // Cleanup
+            this.activeNamespace = undefined
+
+        }
+
+        return this.resolvedModels
+    }
+    
+    protected getActiveNamespace(): string {
+        return this.activeNamespace || ''
+    }
+
+    protected getNamespaceMapper(namespace: ToggleableNamespace): (x: Module) => void {
+        switch(namespace) {
+            case ToggleableNamespace.REQUIRED:
+                return () => { /* do nothing */ }
+            case ToggleableNamespace.OPTIONAL_ON:
+                return (x) => x.required = { value: false }
+            case ToggleableNamespace.OPTIONAL_OFF:
+                return (x) => x.required = { value: false, def: false }
+        }
+    }
+
+}

src/structure/spec_model/module/forgemod/ForgeMod113.struct.ts

@@ -0,0 +1,184 @@
+import StreamZip from 'node-stream-zip'
+import toml from 'toml'
+import { capitalize } from '../../../../util/stringutils'
+import { VersionUtil } from '../../../../util/versionutil'
+import { ModsToml } from '../../../../model/forge/modstoml'
+import { BaseForgeModStructure } from '../ForgeMod.struct'
+import { MinecraftVersion } from '../../../../util/MinecraftVersion'
+
+export class ForgeModStructure113 extends BaseForgeModStructure {
+
+    public static readonly IMPLEMENTATION_VERSION_REGEX = /^Implementation-Version: (.+)[\r\n]/
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public static isForVersion(version: MinecraftVersion, libraryVersion: string): boolean {
+        return VersionUtil.isVersionAcceptable(version, [13, 14, 15, 16])
+    }
+
+    private forgeModMetadata: {[property: string]: ModsToml | undefined} = {}
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, baseUrl, minecraftVersion)
+    }
+
+    public isForVersion(version: MinecraftVersion, libraryVersion: string): boolean {
+        return ForgeModStructure113.isForVersion(version, libraryVersion)
+    }
+
+    public getLoggerName(): string {
+        return 'ForgeModStructure (1.13)'
+    }
+
+    protected async getModuleId(name: string, path: string): Promise<string> {
+        const fmData = await this.getForgeModMetadata(name, path)
+        return this.generateMavenIdentifier(this.getClaritasGroup(path), fmData.mods[0].modId, fmData.mods[0].version)
+    }
+    protected async getModuleName(name: string, path: string): Promise<string> {
+        return capitalize((await this.getForgeModMetadata(name, path)).mods[0].displayName)
+    }
+
+    private getForgeModMetadata(name: string, path: string): Promise<ModsToml> {
+        return new Promise((resolve, reject) => {
+            if (!Object.prototype.hasOwnProperty.call(this.forgeModMetadata, name)) {
+
+                const zip = new StreamZip({
+                    file: path,
+                    storeEntries: true
+                })
+
+                zip.on('error', err => reject(err))
+                zip.on('ready', () => {
+                    try {
+                        const res = this.processZip(zip, name, path)
+                        zip.close()
+                        resolve(res)
+                        return
+                    } catch(err) {
+                        zip.close()
+                        reject(err)
+                        return
+                    }
+                })
+
+            } else {
+                resolve(this.forgeModMetadata[name] as ModsToml)
+                return
+            }
+
+        })
+    }
+
+    private processZip(zip: StreamZip, name: string, path: string): ModsToml {
+
+        // Optifine is a tweak that can be loaded as a forge mod. It does not
+        // appear to contain a mcmod.info class. This a special case we will
+        // account for.
+        if (name.toLowerCase().indexOf('optifine') > -1) {
+
+            // Read zip for changelog.txt
+            let changelogBuf: Buffer
+            try {
+                changelogBuf = zip.entryDataSync('changelog.txt')
+            } catch(err) {
+                throw new Error('Failed to read OptiFine changelog.')
+            }
+
+            const info = changelogBuf.toString().split('\n')[0].trim()
+            const version = info.split(' ')[1]
+
+            this.forgeModMetadata[name] = ({
+                modLoader: 'javafml',
+                loaderVersion: '',
+                mods: [{
+                    modId: 'optifine',
+                    version,
+                    displayName: 'OptiFine',
+                    description: `OptiFine is a Minecraft optimization mod.
+                    It allows Minecraft to run faster and look better with full support for shaders, HD textures and many configuration options.`
+                }]
+            })
+
+            return this.forgeModMetadata[name] as ModsToml
+        }
+
+        let raw: Buffer | undefined
+        try {
+            raw = zip.entryDataSync('META-INF/mods.toml')
+        } catch(err) {
+            // ignored
+        }
+
+        if (raw) {
+            try {
+                const parsed = toml.parse(raw.toString()) as ModsToml
+                this.forgeModMetadata[name] = parsed
+            } catch (err) {
+                this.logger.error(`ForgeMod ${name} contains an invalid mods.toml file.`)
+            }
+        } else {
+            this.logger.error(`ForgeMod ${name} does not contain mods.toml file.`)
+        }
+
+        const cRes = this.claritasResult?.[path]
+
+        if(cRes == null) {
+            this.logger.error(`Claritas failed to yield metadata for ForgeMod ${name}!`)
+            this.logger.error('Is this mod malformated or does Claritas need an update?')
+        }
+
+        const claritasId = cRes?.id
+
+        const crudeInference = this.attemptCrudeInference(name)
+
+        if(this.forgeModMetadata[name] != null) {
+
+            const x = this.forgeModMetadata[name]!
+            for(const entry of x.mods) {
+
+                if(entry.modId === this.EXAMPLE_MOD_ID) {
+                    entry.modId = this.discernResult(claritasId, crudeInference.name.toLowerCase())
+                    entry.displayName = crudeInference.name
+                }
+
+                if (entry.version === '${file.jarVersion}') {
+                    let version = crudeInference.version
+                    try {
+                        const manifest = zip.entryDataSync('META-INF/MANIFEST.MF')
+                        const keys = manifest.toString().split('\n')
+                        this.logger.debug(keys)
+                        for (const key of keys) {
+                            const match = ForgeModStructure113.IMPLEMENTATION_VERSION_REGEX.exec(key)
+                            if (match != null) {
+                                version = match[1]
+                            }
+                        }
+                        this.logger.debug(`ForgeMod ${name} contains a version wildcard, inferring ${version}`)
+                    } catch {
+                        this.logger.debug(`ForgeMod ${name} contains a version wildcard yet no MANIFEST.MF.. Defaulting to ${version}`)
+                    }
+                    entry.version = version
+                }
+            }
+
+        } else {
+            this.forgeModMetadata[name] = ({
+                modLoader: 'javafml',
+                loaderVersion: '',
+                mods: [{
+                    modId: this.discernResult(claritasId, crudeInference.name.toLowerCase()),
+                    version: crudeInference.version,
+                    displayName: crudeInference.name,
+                    description: ''
+                }]
+            })
+        }
+
+        return this.forgeModMetadata[name] as ModsToml
+    }
+
+}

src/structure/spec_model/module/forgemod/ForgeMod17.struct.ts

@@ -0,0 +1,185 @@
+import StreamZip from 'node-stream-zip'
+import { capitalize } from '../../../../util/stringutils'
+import { VersionUtil } from '../../../../util/versionutil'
+import { McModInfo } from '../../../../model/forge/mcmodinfo'
+import { McModInfoList } from '../../../../model/forge/mcmodinfolist'
+import { BaseForgeModStructure } from '../ForgeMod.struct'
+import { MinecraftVersion } from '../../../../util/MinecraftVersion'
+import { ForgeModType_1_7 } from '../../../../model/claritas/ClaritasResult'
+
+export class ForgeModStructure17 extends BaseForgeModStructure {
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public static isForVersion(version: MinecraftVersion, libraryVersion: string): boolean {
+        return VersionUtil.isVersionAcceptable(version, [7, 8, 9, 10, 11, 12])
+    }
+
+    private forgeModMetadata: {[property: string]: McModInfo | undefined} = {}
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        baseUrl: string,
+        minecraftVersion: MinecraftVersion
+    ) {
+        super(absoluteRoot, relativeRoot, baseUrl, minecraftVersion)
+    }
+
+    public isForVersion(version: MinecraftVersion, libraryVersion: string): boolean {
+        return ForgeModStructure17.isForVersion(version, libraryVersion)
+    }
+
+    public getLoggerName(): string {
+        return 'ForgeModStructure (1.7)'
+    }
+
+    protected async getModuleId(name: string, path: string): Promise<string> {
+        const fmData = await this.getForgeModMetadata(name, path)
+        return this.generateMavenIdentifier(this.getClaritasGroup(path), fmData.modid, fmData.version)
+    }
+    protected async getModuleName(name: string, path: string): Promise<string> {
+        return capitalize((await this.getForgeModMetadata(name, path)).name)
+    }
+
+    private getForgeModMetadata(name: string, path: string): Promise<McModInfo> {
+        return new Promise((resolve, reject) => {
+            if (!Object.prototype.hasOwnProperty.call(this.forgeModMetadata, name)) {
+
+                const zip = new StreamZip({
+                    file: path,
+                    storeEntries: true
+                })
+
+                zip.on('error', err => reject(err))
+                zip.on('ready', () => {
+                    try {
+                        const res = this.processZip(zip, name, path)
+                        zip.close()
+                        resolve(res)
+                        return
+                    } catch(err) {
+                        zip.close()
+                        reject(err)
+                        return
+                    }
+                })
+
+            } else {
+                resolve(this.forgeModMetadata[name] as McModInfo)
+                return
+            }
+
+        })
+    }
+
+    private isMalformedVersion(version: string): boolean {
+        // Ex. empty, @VERSION@, ${version}
+        return version.trim().length === 0 || version.indexOf('@') > -1 || version.indexOf('$') > -1
+    }
+
+    private processZip(zip: StreamZip, name: string, path: string): McModInfo {
+        // Optifine is a tweak that can be loaded as a forge mod. It does not
+        // appear to contain a mcmod.info class. This a special case we will
+        // account for.
+        if (name.toLowerCase().indexOf('optifine') > -1) {
+
+            // Read zip for changelog.txt
+            let changelogBuf: Buffer
+            try {
+                changelogBuf = zip.entryDataSync('changelog.txt')
+            } catch(err) {
+                throw new Error('Failed to read OptiFine changelog.')
+            }
+
+            const info = changelogBuf.toString().split('\n')[0].trim()
+            const version = info.split(' ')[1]
+            this.forgeModMetadata[name] = ({
+                modid: 'optifine',
+                name: info,
+                version,
+                mcversion: version.substring(0, version.indexOf('_'))
+            }) as McModInfo
+            return this.forgeModMetadata[name] as McModInfo
+        }
+
+        let raw: Buffer | undefined
+        try {
+            raw = zip.entryDataSync('mcmod.info')
+        } catch(err) {
+            // ignored
+        }
+
+        if (raw) {
+            // Assuming the main mod will be the first entry in this file.
+            try {
+                const resolved = JSON.parse(raw.toString()) as (McModInfoList | McModInfo[])
+
+                if (Object.prototype.hasOwnProperty.call(resolved, 'modListVersion')) {
+                    this.forgeModMetadata[name] = (resolved as McModInfoList).modList[0]
+                } else {
+                    this.forgeModMetadata[name] = (resolved as McModInfo[])[0]
+                }
+
+            } catch (err) {
+                this.logger.error(`ForgeMod ${name} contains an invalid mcmod.info file.`)
+            }
+        } else {
+            this.logger.warn(`ForgeMod ${name} does not contain mcmod.info file.`)
+        }
+
+        const cRes = this.claritasResult[path]
+
+        if(cRes == null) {
+            this.logger.error(`Claritas failed to yield metadata for ForgeMod ${name}!`)
+            this.logger.error('Is this mod malformated or does Claritas need an update?')
+        } else {
+            switch(cRes.modType!) {
+                case ForgeModType_1_7.CORE_MOD:
+                    this.logger.info(`CORE_MOD Discovered: ForgeMod ${name} has no @Mod annotation. Metadata inference capabilities are limited.`)
+                    break
+                case ForgeModType_1_7.TWEAKER:
+                    this.logger.info(`TWEAKER Discovered: ForgeMod ${name} has no @Mod annotation. Metadata inference capabilities may be limited.`)
+                    break
+                case ForgeModType_1_7.UNKNOWN:
+                    this.logger.error(`Jar file ${name} is not a ForgeMod. Is it a library?`)
+                    break
+            }
+        }
+
+        const claritasId = cRes?.id
+        const claritasVersion = cRes?.version
+        const claritasName = cRes?.name
+
+
+        // Validate
+        const crudeInference = this.attemptCrudeInference(name)
+        if(this.forgeModMetadata[name] != null) {
+            
+            const x = this.forgeModMetadata[name]!
+            if(x.modid == null || x.modid === '' || x.modid === this.EXAMPLE_MOD_ID) {
+                x.modid = this.discernResult(claritasId, crudeInference.name.toLowerCase())
+                x.name = this.discernResult(claritasName, crudeInference.name)
+            }
+
+            if(this.forgeModMetadata[name]!.version != null) {
+                const isMalformedVersion = this.isMalformedVersion(this.forgeModMetadata[name]!.version)
+                if(isMalformedVersion) {
+                    x.version = this.discernResult(claritasVersion, crudeInference.version)
+                }
+            } else {
+                x.version = this.discernResult(claritasVersion, crudeInference.version)
+            }
+            
+            
+        } else {
+            this.forgeModMetadata[name] = ({
+                modid: this.discernResult(claritasId, crudeInference.name.toLowerCase()),
+                name: this.discernResult(claritasName, crudeInference.name),
+                version: this.discernResult(claritasVersion, crudeInference.version)
+            }) as McModInfo
+        }
+
+        return this.forgeModMetadata[name] as McModInfo
+    }
+
+}