@nan0web/release 3.4.0 → 3.5.0

package/src/domain/PMaCParser.story.js

@@ -0,0 +1,152 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import {
+	ReleaseModel,
+	ReleaseTaskModel,
+	ReleaseParityModel,
+	ReleaseIssueModel,
+} from './models/index.js'
+import { PMaCParser, resolveTrackerUrl } from './PMaCParser.js'
+
+describe('PMaC Parser & Release Models Contract', () => {
+	const sampleMarkdown = `---
+status: work
+type: minor
+epic: EPIC-CORE-42
+sprint: Sprint 42
+tracker: https://github.com/nan0web/nan.web/issues/{id}
+---
+
+# v0.1.0 — Core Release Engine & Payload CMS Plugin Integration
+
+## Опис та Мета
+Плагін @nan0web/payload-release для Payload CMS 3.x, що забезпечує автоматичну фіксацію запусків релізів.
+
+## Команда
+- **Lead / Architect:** Олександр Снігірьов (@snigirev)
+- **AI Lead Developer:** Agent Antigravity (@agy)
+
+## Робочий План та Задачі
+
+### 1. Архітектурна ізоляція моделей [#101]
+- [x] [#101-1] Винести базову модель ReleaseModel у пакет @nan0web/release
+- [x] [#101-2] Реалізувати уніфікований AST-парсер специфікацій на базі @nan0web/markdown
+- [ ] [#101-3] Забезпечити 100% покриття контрактними тестами
+
+### 2. Payload CMS Адаптер [#102]
+- [x] [#102-1] Реалізувати колекцію releases з табами
+- [ ] [#102-3] Перегляд вмісту специфікацій через модальне вікно
+
+## Аудит та Паритет Даних
+| Колекція | Очікувано | Фактично | Статус | Коментар |
+| :--- | :---: | :---: | :---: | :--- |
+| \`users\` | 12 | 12 | ✅ OK | Синхронізовано |
+| \`media\` | 45 | 44 | ⚠️ Mismatch | Відсутній аватар для demo |
+
+## Зауваження та Ризики
+- **[WARN-001]** (Performance) Файли розміром > 2MB не повинні відкриватися без пагінації.
+- **[INFO-002]** (Environment) Node.js v20.x є мінімально підтримуваною версією.
+
+## Артефакти
+| Файл | Розмір | SHA-256 | Тип |
+| :--- | :---: | :--- | :--- |
+| \`task.md\` | 6.0 KB | \`e3b0c442...\` | ТЗ / Специфікація |
+`
+
+	it('ReleaseModel instantiates with schema defaults and validates', () => {
+		const release = new ReleaseModel({
+			version: 'v0.1.0',
+			title: 'Core Release Engine',
+		})
+
+		assert.strictEqual(release.version, 'v0.1.0')
+		assert.strictEqual(release.title, 'Core Release Engine')
+		assert.strictEqual(release.status, 'todo')
+		assert.strictEqual(release.type, 'minor')
+		assert.deepStrictEqual(release.tasks, [])
+		assert.deepStrictEqual(release.parity, [])
+		assert.deepStrictEqual(release.issues, [])
+		assert.strictEqual(release.validate(), true)
+	})
+
+	it('PMaCParser extracts version, title and metadata from H1 and frontmatter', () => {
+		const release = PMaCParser.parse(sampleMarkdown)
+
+		assert.strictEqual(release.version, 'v0.1.0')
+		assert.strictEqual(release.title, 'Core Release Engine & Payload CMS Plugin Integration')
+		assert.strictEqual(release.status, 'work')
+		assert.strictEqual(release.type, 'minor')
+		assert.strictEqual(release.epic, 'EPIC-CORE-42')
+		assert.strictEqual(release.sprint, 'Sprint 42')
+		assert.strictEqual(release.tracker, 'https://github.com/nan0web/nan.web/issues/{id}')
+		assert.ok(release.summary.includes('Плагін @nan0web/payload-release'))
+	})
+
+	it('PMaCParser parses tasks with status and IDs', () => {
+		const release = PMaCParser.parse(sampleMarkdown)
+
+		assert.strictEqual(release.tasks.length, 5)
+		const task1 = release.tasks[0]
+		assert.strictEqual(task1.id, '101-1')
+		assert.strictEqual(task1.title, 'Винести базову модель ReleaseModel у пакет @nan0web/release')
+		assert.strictEqual(task1.status, 'done')
+
+		const task3 = release.tasks[2]
+		assert.strictEqual(task3.id, '101-3')
+		assert.strictEqual(task3.status, 'todo')
+	})
+
+	it('PMaCParser parses data parity table into ReleaseParityModel items', () => {
+		const release = PMaCParser.parse(sampleMarkdown)
+
+		assert.strictEqual(release.parity.length, 2)
+		const p1 = release.parity[0]
+		assert.strictEqual(p1.collection, 'users')
+		assert.strictEqual(p1.expected, 12)
+		assert.strictEqual(p1.actual, 12)
+		assert.strictEqual(p1.synced, true)
+
+		const p2 = release.parity[1]
+		assert.strictEqual(p2.collection, 'media')
+		assert.strictEqual(p2.expected, 45)
+		assert.strictEqual(p2.actual, 44)
+		assert.strictEqual(p2.synced, false)
+	})
+
+	it('PMaCParser parses issues and risks into ReleaseIssueModel items', () => {
+		const release = PMaCParser.parse(sampleMarkdown)
+
+		assert.strictEqual(release.issues.length, 2)
+		const issue1 = release.issues[0]
+		assert.strictEqual(issue1.code, 'WARN-001')
+		assert.strictEqual(issue1.level, 'warning')
+		assert.ok(issue1.message.includes('(Performance)'))
+
+		const issue2 = release.issues[1]
+		assert.strictEqual(issue2.code, 'INFO-002')
+		assert.strictEqual(issue2.level, 'info')
+	})
+
+	it('PMaCParser parses artifacts table into files array', () => {
+		const release = PMaCParser.parse(sampleMarkdown)
+
+		assert.strictEqual(release.files.length, 1)
+		assert.strictEqual(release.files[0].file, 'task.md')
+		assert.strictEqual(release.files[0].size, '6.0 KB')
+	})
+
+	it('resolveTrackerUrl resolves templated ticket URLs', () => {
+		const url = resolveTrackerUrl('[#142]', 'https://github.com/nan0web/nan.web/issues/{id}')
+		assert.strictEqual(url, 'https://github.com/nan0web/nan.web/issues/142')
+
+		const url2 = resolveTrackerUrl('PROJ-99', 'https://jira.company.com/browse/{id}')
+		assert.strictEqual(url2, 'https://jira.company.com/browse/PROJ-99')
+	})
+
+	it('ReleaseModel.addLocaleSections extends recognized synonyms', () => {
+		ReleaseModel.addLocaleSections({
+			tasks: ['aufgaben', 'arbeitsplan'],
+		})
+		assert.ok(ReleaseModel.SECTIONS.tasks.includes('aufgaben'))
+	})
+})

package/src/domain/ValidateCommand.js

@@ -0,0 +1,426 @@
+import { ModelAsApp, show, result, progress } from '@nan0web/ui'
+import { NaN0 } from '@nan0web/types'
+import { stringifyCSV } from '@nan0web/csv0'
+import { RegistryModel } from './Registry/RegistryModel.js'
+import { DashboardModel } from './Dashboard/DashboardModel.js'
+import { PMaCParser } from './PMaCParser.js'
+import { ReleaseAuditor } from './inspect/ReleaseAuditor.js'
+
+/**
+ * ValidateCommand - CLI Release Inspector & Multi-Format Validator.
+ * Validates PMaC compliance, tasks, criteria, parity and outputs in text, json, nan0, or csv.
+ */
+export class ValidateCommand extends ModelAsApp {
+	static alias = 'validate'
+
+	static UI = {
+		title: 'PM-as-Code Release Inspector & Multi-Format Validator',
+		header: '🔍 Release Inspector & Validator (nan0release validate)',
+		scanningCount: 'Scanning {count} project(s)...',
+		projectHeader: '\n📦 Project: {name} ({path})',
+		noReleases: '  ⚠️ No releases discovered in {path}',
+		savedReport: '💾 Report saved to {path}',
+		summary: '\n📊 Validation Summary: {projects} project(s) checked | {releases} release(s) | Status: {status}',
+	}
+
+	static target = {
+		help: 'Target path, package name, or release directory to validate',
+		default: '',
+		type: 'string',
+		positional: true,
+	}
+
+	static format = {
+		help: 'Output format (text, json, nan0, csv)',
+		default: 'text',
+		options: ['text', 'json', 'nan0', 'csv'],
+		type: 'string',
+		alias: 'm',
+	}
+
+	static output = {
+		help: 'Path to save output report file',
+		default: '',
+		type: 'string',
+		alias: 'o',
+	}
+
+	static registryFile = {
+		help: 'Path to releases.txt registry file',
+		default: 'releases.txt',
+		type: 'string',
+		alias: 'f',
+	}
+
+	static all = {
+		help: 'Validate all projects registered in releases.txt',
+		default: false,
+		type: 'boolean',
+		alias: 'a',
+	}
+
+	/**
+	 * @param {Partial<ValidateCommand>} [data]
+	 * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+		/** @type {string} */ this.target = String(data.target || '')
+		/** @type {'text' | 'json' | 'nan0' | 'csv'} */ this.format = data.format || 'text'
+		/** @type {string} */ this.output = String(data.output || '')
+		/** @type {string} */ this.registryFile = String(data.registryFile || 'releases.txt')
+		/** @type {boolean} */ this.all = Boolean(data.all)
+	}
+
+	/**
+	 * Execute release validation and format rendering
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, { success: boolean, releases: any[], output: string }, any>}
+	 */
+	async *run() {
+		const db = this.$db
+		const t = this._.t
+
+		const format = this.format || 'text'
+		if (format === 'text') {
+			yield show(t(ValidateCommand.UI.header))
+		}
+
+		// 1. Resolve targets
+		const targets = await this.#resolveTargets(db)
+		if (format === 'text') {
+			yield progress(t(ValidateCommand.UI.scanningCount, { count: targets.length }))
+		}
+
+		const parser = new PMaCParser()
+		const validatedReleases = []
+		let allValid = true
+
+		for (const target of targets) {
+			const projectRoot = target.path === '.' ? '' : `${target.path.replace(/\/+$/, '')}/`
+			if (format === 'text') {
+				yield show(t(ValidateCommand.UI.projectHeader, { name: target.name, path: target.path }))
+			}
+
+			// Run ReleaseAuditor for project
+			const auditor = new ReleaseAuditor({ dir: target.path }, { db })
+			await auditor.init()
+			const auditGen = auditor.run()
+			let aStep = await auditGen.next()
+			while (!aStep.done) {
+				aStep = await auditGen.next()
+			}
+			const auditRes = aStep.value?.data || aStep.value
+			if (auditRes && auditRes.success === false) {
+				allValid = false
+			}
+
+			// Discover release dirs (support both nested and flat)
+			const releaseDirs = await this.#discoverReleases(db, projectRoot)
+
+			if (releaseDirs.length === 0 && format === 'text') {
+				yield show(t(ValidateCommand.UI.noReleases, { path: target.path }), 'warn')
+			}
+
+			const projectDiagnostics = auditRes?.diagnostics || [
+				...(auditRes?.errors || []),
+				...(auditRes?.warnings || []),
+			]
+
+			for (const rel of releaseDirs) {
+				const releaseData = await this.#loadAndParseRelease(db, rel, parser)
+				releaseData.projectDiagnostics = projectDiagnostics
+				const relErrors = (auditRes?.errors || []).filter(
+					(e) => !e.file || e.file.startsWith(rel.path) || e.file === `${projectRoot}package.json`
+				)
+				const relWarnings = (auditRes?.warnings || []).filter(
+					(e) => !e.file || e.file.startsWith(rel.path)
+				)
+				releaseData.errors = relErrors
+				releaseData.warnings = relWarnings
+				releaseData.valid = relErrors.length === 0
+				if (!releaseData.valid) allValid = false
+
+				validatedReleases.push(releaseData)
+			}
+		}
+
+		if (format === 'text') {
+			yield progress('')
+		}
+
+		// 2. Render output based on format
+		let outputStr = ''
+		switch (format) {
+			case 'json':
+				outputStr = this.#renderJson(allValid, validatedReleases)
+				break
+			case 'nan0':
+				outputStr = this.#renderNan0(allValid, validatedReleases)
+				break
+			case 'csv':
+				outputStr = this.#renderCsv(validatedReleases)
+				break
+			case 'text':
+			default:
+				outputStr = this.#renderText(validatedReleases)
+				break
+		}
+
+		// 3. Save to file if --output specified
+		if (this.output) {
+			await db.saveDocument(this.output, outputStr)
+			if (format === 'text') {
+				yield show(t(ValidateCommand.UI.savedReport, { path: this.output }), 'success')
+			}
+		} else if (format !== 'text') {
+			// For non-text stdout formats
+			yield show(outputStr)
+		} else {
+			yield show(outputStr)
+		}
+
+		if (format === 'text') {
+			yield show(
+				t(ValidateCommand.UI.summary, {
+					projects: targets.length,
+					releases: validatedReleases.length,
+					status: allValid ? 'PASSED ✅' : 'FAILED ❌',
+				}),
+				allValid ? 'success' : 'warn'
+			)
+		}
+
+		return result({
+			success: allValid,
+			releases: validatedReleases,
+			output: outputStr,
+		})
+	}
+
+	async #resolveTargets(db) {
+		const targetParam = (this.target || '').trim()
+
+		// Direct release directory?
+		if (targetParam && (targetParam.includes('releases/') || targetParam.endsWith('releases'))) {
+			return [{ path: targetParam, name: targetParam, version: '0.0.0', isDirectReleases: true }]
+		}
+
+		const registry = new RegistryModel({ filePath: this.registryFile || 'releases.txt' }, { db })
+		let registeredProjects = []
+		try {
+			registeredProjects = await registry.loadProjects()
+		} catch {
+			registeredProjects = []
+		}
+
+		if (this.all || (!targetParam && registeredProjects.length > 0)) {
+			return registeredProjects
+		}
+
+		if (targetParam) {
+			const matched = registeredProjects.find(
+				(p) =>
+					p.name === targetParam ||
+					p.path === targetParam ||
+					p.path === targetParam.replace(/\/+$/, '')
+			)
+			if (matched) return [matched]
+			return [{ path: targetParam, name: targetParam, version: '0.0.0' }]
+		}
+
+		return [{ path: '.', name: 'current-project', version: '0.0.0' }]
+	}
+
+	async #discoverReleases(db, projectRoot) {
+		const results = []
+		// If target was directly releases/ or path contains releases
+		let releasesUri = ''
+		if (projectRoot.includes('releases/') || projectRoot.endsWith('releases')) {
+			releasesUri = projectRoot.replace(/\/+$/, '')
+		} else {
+			releasesUri = `${projectRoot}releases`.replace(/^\/+/, '') || 'releases'
+		}
+
+		try {
+			if (typeof db.listDir === 'function') {
+				const queue = [{ uri: releasesUri, depth: 0 }]
+				while (queue.length > 0) {
+					const item = queue.shift()
+					if (!item || item.depth > 3) continue
+					let entries = []
+					try {
+						entries = await db.listDir(item.uri)
+					} catch {
+						continue
+					}
+					if (!Array.isArray(entries)) continue
+
+					for (const entry of entries) {
+						const rawName = entry.name || (entry.path || '').split('/').pop() || ''
+						const name = rawName.replace(/\/$/, '')
+						const isDir = Boolean(
+							entry.stat?.isDirectory ||
+								entry.isDirectory ||
+								entry.isDir ||
+								rawName.endsWith('/')
+						)
+
+						const dirMatch = name.match(/^v(\d+\.\d+\.\d+[a-zA-Z0-9._-]*)/)
+						if (dirMatch) {
+							const version = `v${dirMatch[1]}`
+							const entryPath = entry.path ? entry.path.replace(/\/$/, '') : `${item.uri}/${name}`
+							const normalizedPath = entryPath.replace(/^\.\//, '')
+							if (!results.find((r) => r.path === normalizedPath)) {
+								results.push({ version, path: normalizedPath })
+							}
+						} else if (isDir && !name.startsWith('.') && name !== 'node_modules' && name !== '_') {
+							const nextUri = entry.path ? entry.path.replace(/\/$/, '') : `${item.uri}/${name}`
+							queue.push({ uri: nextUri, depth: item.depth + 1 })
+						}
+					}
+				}
+			}
+		} catch {}
+
+		return results
+	}
+
+	async #loadAndParseRelease(db, rel, parser) {
+		let releaseContent = ''
+		let docName = ''
+		for (const candidate of ['release.md', 'task.md', 'plan.md']) {
+			try {
+				const doc = await db.loadDocument(`${rel.path}/${candidate}`, null)
+				if (doc) {
+					releaseContent = String(doc)
+					docName = candidate
+					break
+				}
+			} catch {}
+		}
+
+		let userContent = ''
+		try {
+			const u = await db.loadDocument(`${rel.path}/user.md`, null)
+			if (u) userContent = typeof u === 'object' ? JSON.stringify(u) : String(u)
+		} catch {}
+
+		const userMetrics = DashboardModel.parseUserMetrics(userContent)
+
+		let parsed = null
+		if (releaseContent) {
+			parsed = parser.parse(releaseContent)
+		}
+
+		return {
+			version: rel.version,
+			path: rel.path,
+			doc: docName,
+			title: parsed?.title || '',
+			status: parsed?.status || 'todo',
+			type: parsed?.type || 'minor',
+			epic: parsed?.epic || '',
+			sprint: parsed?.sprint || '',
+			tracker: parsed?.tracker || '',
+			team: parsed?.team || [],
+			tasks: parsed?.tasks || [],
+			criteria: parsed?.criteria || [],
+			parity: parsed?.parity || [],
+			issues: parsed?.issues || [],
+			userMetrics,
+		}
+	}
+
+	#renderText(releases) {
+		const lines = []
+		for (const rel of releases) {
+			const statusBadge = rel.valid ? '✅ VALID' : '❌ INVALID'
+			lines.push(`\n  Release [${rel.version}] ${statusBadge}`)
+			lines.push(`  Path: ${rel.path}`)
+			if (rel.title) lines.push(`  Title: ${rel.title}`)
+			lines.push(`  Status: ${rel.status} | Type: ${rel.type}`)
+			if (rel.userMetrics) {
+				lines.push(
+					`  Metrics: ${rel.userMetrics.hours}h | ${rel.userMetrics.iterations} iters | RRS: ${rel.userMetrics.rrs}`
+				)
+			}
+			const doneTasks = rel.tasks.filter((t) => t.status === 'done').length
+			lines.push(`  Tasks: ${doneTasks}/${rel.tasks.length} completed`)
+			for (const task of rel.tasks) {
+				const mark = task.status === 'done' ? '✔' : '○'
+				lines.push(`    ${mark} [${task.id}] ${task.title}`)
+			}
+			if (rel.parity?.length > 0) {
+				lines.push(`  Parity Check (${rel.parity.length} collections):`)
+				for (const p of rel.parity) {
+					const pMark = p.synced ? '✅' : '⚠️'
+					lines.push(`    ${pMark} ${p.collection}: ${p.actual}/${p.expected} (${p.comment || ''})`)
+				}
+			}
+			if (rel.errors?.length > 0) {
+				lines.push(`  Errors / Recommendations (${rel.errors.length}):`)
+				for (const err of rel.errors) {
+					lines.push(`    ❌ [${err.code}] ${err.error || err.message}`)
+					if (err.fix) lines.push(`       👉 Fix: ${err.fix}`)
+				}
+			}
+			if (rel.warnings?.length > 0) {
+				lines.push(`  Warnings (${rel.warnings.length}):`)
+				for (const warn of rel.warnings) {
+					lines.push(`    ⚠️ [${warn.code}] ${warn.error || warn.message}`)
+					if (warn.fix) lines.push(`       👉 Fix: ${warn.fix}`)
+				}
+			}
+		}
+		return lines.join('\n')
+	}
+
+	#renderJson(allValid, releases) {
+		return JSON.stringify(
+			{
+				success: allValid,
+				timestamp: new Date().toISOString(),
+				total: releases.length,
+				releases,
+			},
+			null,
+			2
+		)
+	}
+
+	#renderNan0(allValid, releases) {
+		const payload = {
+			success: allValid,
+			total: releases.length,
+			releases: releases.map((rel) => ({
+				version: rel.version,
+				path: rel.path,
+				status: rel.status,
+				type: rel.type,
+				title: rel.title,
+				valid: rel.valid,
+				tasks_total: rel.tasks.length,
+				tasks_done: rel.tasks.filter((t) => t.status === 'done').length,
+			})),
+		}
+		return `# nan0 release validation report\n${NaN0.stringify(payload)}`
+	}
+
+	#renderCsv(releases) {
+		const rows = []
+		for (const rel of releases) {
+			for (const task of rel.tasks) {
+				rows.push({
+					Version: rel.version,
+					'Task ID': task.id,
+					Title: task.title || '',
+					Status: task.status || 'todo',
+					Notes: task.notes || '',
+				})
+			}
+		}
+		return stringifyCSV(rows)
+	}
+}
+
+export default ValidateCommand

package/src/domain/ValidateCommand.story.js

@@ -0,0 +1,92 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import DB from '@nan0web/db'
+import { ValidateCommand } from './ValidateCommand.js'
+
+describe('Scenario: ValidateCommand Multi-Format Inspection with In-Memory DB', () => {
+	it('executes full scan and renders formatted report', async () => {
+		const releaseMd = `---
+status: work
+type: minor
+epic: EPIC-CORE
+sprint: Sprint 1
+tracker: https://github.com/nan0web/nan.web/issues/{id}
+---
+
+# v1.0.0 — Core Release Inspector
+
+## Опис та Мета
+Створення CLI інструменту інспекції релізів.
+
+## Команда
+- **Lead / Architect:** Олександр Снігірьов (@snigirev)
+- **AI Lead Developer:** Agent Antigravity (@agy)
+
+## Робочий План та Задачі
+- [x] [#101] Core inspection logic
+- [ ] [#102] Multi-format reporter
+
+## Паритет Даних
+| Колекція | Очікувано | Фактично | Статус | Коментар |
+| :--- | :---: | :---: | :---: | :--- |
+| releases | 1 | 1 | ✅ OK | Synced |
+`
+		const userMd = `---
+hours: 1.5
+iterations: 4
+rrs: 330
+---
+# Metrics
+Hours: 1.5h
+Iterations: 4
+RRS: 330
+`
+
+		const db = new DB({
+			predefined: [
+				['package.json', { name: '@nan0web/sample', version: '1.0.0' }],
+				['releases/1/0/v1.0.0/release.md', releaseMd],
+				['releases/1/0/v1.0.0/user.md', userMd],
+				['releases/1/0/v1.0.0/task.spec.js', '// spec'],
+			],
+		})
+		await db.connect()
+
+		// 1. Text format
+		const cmdText = new ValidateCommand({ target: '.' }, { db })
+		const genText = cmdText.run()
+		let step = await genText.next()
+		while (!step.done) {
+			step = await genText.next()
+		}
+		const resText = step.value?.data || step.value
+		assert.ok(resText.success)
+		assert.equal(resText.releases.length, 1)
+		assert.match(resText.output, /Release \[v1\.0\.0\] ✅ VALID/)
+		assert.match(resText.output, /Core inspection logic/)
+
+		// 2. JSON format
+		const cmdJson = new ValidateCommand({ target: '.', format: 'json' }, { db })
+		const genJson = cmdJson.run()
+		step = await genJson.next()
+		while (!step.done) {
+			step = await genJson.next()
+		}
+		const resJson = step.value?.data || step.value
+		assert.ok(resJson.success)
+		const parsed = JSON.parse(resJson.output)
+		assert.equal(parsed.releases[0].tasks.length, 2)
+		assert.equal(parsed.releases[0].parity.length, 1)
+
+		// 3. CSV format with file export
+		const cmdCsv = new ValidateCommand({ target: '.', format: 'csv', output: 'export.csv' }, { db })
+		const genCsv = cmdCsv.run()
+		step = await genCsv.next()
+		while (!step.done) {
+			step = await genCsv.next()
+		}
+		const savedCsv = await db.loadDocument('export.csv', null)
+		assert.ok(savedCsv)
+		assert.match(savedCsv, /v1\.0\.0,101,Core inspection logic,done/)
+	})
+})

package/src/domain/models/ReleaseIssueModel.js

@@ -0,0 +1,27 @@
+import { Model } from '@nan0web/types'
+
+export class ReleaseIssueModel extends Model {
+	static level = { type: 'string', default: 'warning' } // 'error' | 'warning' | 'info'
+	static code = { type: 'string' }
+	static message = { type: 'string', required: true }
+	static source = { type: 'string' }
+	static file = { type: 'string' }
+
+	/**
+	 * @param {Partial<ReleaseIssueModel>} [data={}]
+	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+		/** @type { 'error' | 'warning' | 'info' } Level of issue */
+		this.level
+		/** @type {string} Issue code */
+		this.code
+		/** @type {string} Issue message */
+		this.message
+		/** @type {string} Issue source */
+		this.source
+		/** @type {string} Issue file */
+		this.file
+	}
+}