@nan0web/release 3.2.0 → 3.4.0

package/src/domain/Dashboard/ReleaseDiscovery.js

@@ -0,0 +1,132 @@
+import { extractTasks } from './ReleaseParser.js'
+
+/**
+ * Parse semver string into [major, minor, patch] numbers
+ * @param {string} [v='']
+ * @returns {[number, number, number]}
+ */
+export function parseSemver(v = '') {
+	const match = String(v).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/)
+	if (!match) return [0, 0, 0]
+	return [
+		parseInt(match[1] || '0', 10),
+		parseInt(match[2] || '0', 10),
+		parseInt(match[3] || '0', 10),
+	]
+}
+
+/**
+ * Compare two semver strings in descending order
+ * @param {string} [a='']
+ * @param {string} [b='']
+ * @returns {number}
+ */
+export function compareSemverDesc(a = '', b = '') {
+	const pa = parseSemver(a)
+	const pb = parseSemver(b)
+	if (pa[0] !== pb[0]) return pb[0] - pa[0]
+	if (pa[1] !== pb[1]) return pb[1] - pa[1]
+	return pb[2] - pa[2]
+}
+
+/**
+ * Format release version to path segments e.g. "1.0.0" -> "1/0/v1.0.0"
+ * @param {string} [version='']
+ * @returns {string}
+ */
+export function versionToPath(version = '') {
+	const clean = version.replace(/^v/, '')
+	const parts = clean.split('.').slice(0, 2)
+	return [...parts, `v${clean}`].join('/')
+}
+
+/**
+ * Check whether a document exists in the virtual database
+ * @param {any} db
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+export async function documentExists(db, path) {
+	try {
+		const doc = await db.loadDocument(path, null)
+		return doc !== null && doc !== undefined
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Load release doc (release.md, task.md, plan.md) and extract tasks
+ * @param {any} db
+ * @param {string} releaseDir
+ * @returns {Promise<{ releaseContent: string, sourceDoc: string, tasks: import('./ReleaseParser.js').TaskItem[] }>}
+ */
+export async function loadReleaseDoc(db, releaseDir) {
+	let releaseContent = ''
+	let sourceDoc = `${releaseDir}/release.md`
+	for (const docFile of ['release.md', 'task.md', 'plan.md']) {
+		try {
+			const content = await db.loadDocument(`${releaseDir}/${docFile}`, '')
+			if (content) {
+				releaseContent = content
+				sourceDoc = `${releaseDir}/${docFile}`
+				break
+			}
+		} catch {}
+	}
+	return { releaseContent, sourceDoc, tasks: releaseContent ? extractTasks(releaseContent) : [] }
+}
+
+/**
+ * Discover release version directories using database listDir
+ * @param {any} db
+ * @param {string} projectRoot
+ * @returns {Promise<Array<{ version: string, path: string }>>}
+ */
+export async function discoverReleases(db, projectRoot) {
+	const results = []
+	const 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 = 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.sort((a, b) => compareSemverDesc(a.version, b.version))
+}

package/src/domain/Dashboard/ReleaseParser.js

@@ -0,0 +1,226 @@
+/**
+ * @typedef {Object} TaskItem
+ * @property {string} content - Task title or description
+ * @property {string} status - todo | InProgress | Done
+ * @property {string} slug - Task slug / identifier
+ * @property {'0' | '1' | '2' | '3'} [priority] - Numeric priority
+ */
+
+/**
+ * Parse frontmatter YAML from markdown text
+ * @param {*} input
+ * @returns {Record<string, any>}
+ */
+export function parseFrontmatter(input) {
+	const content = String(input || '')
+	if (!content.trim()) return {}
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+	if (!match) return {}
+	const res = {}
+	for (const rawLine of match[1].split('\n')) {
+		const line = rawLine.trim()
+		if (!line || line.startsWith('#') || !line.includes(':')) continue
+		const key = line.slice(0, line.indexOf(':')).trim()
+		const val = line.slice(line.indexOf(':') + 1).trim().replace(/^['"](.*)['"]$/, '$1')
+		res[key] = val
+	}
+	return res
+}
+
+/**
+ * Normalize priority to numeric string '0' | '1' | '2' | '3'
+ * @param {any} input
+ * @returns {'0' | '1' | '2' | '3'}
+ */
+export function normalizePriority(input) {
+	const str = String(input ?? '1').trim().toLowerCase()
+	if (str === '0' || str === 'p0' || str.includes('urgent') || str.includes('high') || str.includes('критич')) return '0'
+	if (str === '2' || str === 'p2' || str.includes('low') || str.includes('backlog') || str.includes('фон')) return '2'
+	if (str === '3' || str === 'p3') return '3'
+	return '1'
+}
+
+function detectPriority(text) {
+	const m = text.match(/\b(p0|p1|p2|p3|urgent|high|med|medium|low)\b/i)
+	if (!m) return '1'
+	const p = m[1].toLowerCase()
+	if (p === 'p0' || p === 'urgent' || p === 'high') return '0'
+	if (p === 'p2') return '2'
+	if (p === 'p3' || p === 'low') return '3'
+	return '1'
+}
+
+function cleanTaskTitle(text) {
+	return text.replace(/\[\s*\]\([^)]+\)/g, '').replace(/\[([^\]]+)\]$/, '').replace(/^\*\*|\*\*$/g, '').trim()
+}
+
+/**
+ * Extract clean task items from release markdown
+ * @param {*} input
+ * @returns {TaskItem[]}
+ */
+export function extractTasks(input) {
+	const content = String(input || '')
+	if (!content.trim()) return []
+	const tasks = []
+
+	for (const rawLine of content.split('\n')) {
+		const line = rawLine.trim()
+		if (!line) continue
+
+		const checkMatch = line.match(/^[-*+]?\s*(?:\[([ xX])\]|\d+\.\s*\[([ xX])\])\s*(.+)$/)
+		if (checkMatch) {
+			const isChecked = (checkMatch[1] || checkMatch[2] || '').toLowerCase() === 'x'
+			const text = cleanTaskTitle(checkMatch[3])
+			tasks.push({
+				content: text,
+				status: isChecked ? 'Done' : 'Todo',
+				slug: text.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+				priority: detectPriority(checkMatch[3]),
+			})
+			continue
+		}
+
+		const headingMatch = line.match(/^###\s*(Done|InProgress|Todo|Draft)\s+(.+)$/i)
+		if (headingMatch) {
+			const statusWord = headingMatch[1].toLowerCase()
+			const rawTitle = headingMatch[2].trim()
+			const slugMatch = rawTitle.match(/\[([^\]]+)\]$/)
+			const slug = slugMatch ? slugMatch[1] : ''
+			const text = cleanTaskTitle(rawTitle)
+			const status = statusWord === 'done' ? 'Done' : statusWord === 'inprogress' ? 'InProgress' : 'Todo'
+			tasks.push({
+				content: text,
+				status,
+				slug: slug || text.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+				priority: detectPriority(rawTitle),
+			})
+			continue
+		}
+
+		const numMatch = line.match(/^###\s*\d+\.\s*(.+)$/)
+		if (numMatch) {
+			const rawTitle = numMatch[1].trim()
+			if (/^(Team|Tasks|Overview|Section|User Stories|Feedback|Acceptance Criteria)/i.test(rawTitle)) continue
+			const text = cleanTaskTitle(rawTitle)
+			if (text.length > 0) {
+				tasks.push({
+					content: text,
+					status: 'Todo',
+					slug: text.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+					priority: detectPriority(rawTitle),
+				})
+			}
+		}
+	}
+	return tasks
+}
+
+/**
+ * Calculate days remaining until deadline
+ * @param {string} [deadlineStr]
+ * @returns {number | null}
+ */
+export function calculateDaysRemaining(deadlineStr = '') {
+	if (!deadlineStr) return null
+	try {
+		const target = new Date(deadlineStr)
+		if (isNaN(target.getTime())) return null
+		return Math.ceil((target.getTime() - Date.now()) / (1000 * 60 * 60 * 24))
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Parse user.md content for telemetry metrics (hours, iterations, RRS) across languages
+ * @param {*} [input]
+ * @returns {{ hours: number, iterations: number, rrs: number }}
+ */
+export function parseUserMetrics(input = '') {
+	const content = String(input || '')
+	if (!content.trim()) return { hours: 0, iterations: 0, rrs: 0 }
+
+	let hours = 0, iterations = 0, rrs = 0
+	const fm = parseFrontmatter(content)
+	if (fm.hours || fm.spentHours || fm.time) hours = parseFloat(fm.hours || fm.spentHours || fm.time || '0') || 0
+	if (fm.iterations || fm.iters || fm.runs) iterations = parseInt(fm.iterations || fm.iters || fm.runs || '0', 10) || 0
+	if (fm.rrs || fm.score) rrs = parseInt(fm.rrs || fm.score || '0', 10) || 0
+
+	for (const rawLine of content.split('\n')) {
+		const line = rawLine.trim()
+		if (!line || !line.includes(':')) continue
+		const beforeColon = line.slice(0, line.indexOf(':')).toLowerCase()
+		const numMatch = line.slice(line.indexOf(':') + 1).match(/([0-9]+(?:\.[0-9]+)?)/)
+		if (!numMatch) continue
+		const val = parseFloat(numMatch[1])
+
+		if (hours === 0 && /(витрачений час|час розробки|time spent|development time|spent time|dev hours|hours|годин)/.test(beforeColon)) {
+			hours = val
+		} else if (iterations === 0 && /(кількість ітерацій|ітерацій|iteration count|test runs|refactor runs|iterations|runs)/.test(beforeColon)) {
+			iterations = Math.round(val)
+		} else if (rrs === 0 && /(rrs|release readiness score|фінальний бал|бал rrs|readiness score)/.test(beforeColon)) {
+			rrs = Math.round(val)
+		}
+	}
+	return { hours, iterations, rrs }
+}
+
+/**
+ * Resolve priority from frontmatter or days remaining
+ * @param {Record<string, any>} fm
+ * @param {number | null} daysRemaining
+ * @returns {'0' | '1' | '2' | '3'}
+ */
+export function resolvePriority(fm = {}, daysRemaining = null) {
+	let priority = '1'
+	const rawPrio = String(fm.priority || fm.prio || '').toLowerCase()
+	if (rawPrio.includes('p0') || rawPrio.includes('high') || rawPrio.includes('urgent') || rawPrio.includes('критич')) priority = '0'
+	else if (rawPrio.includes('p2') || rawPrio.includes('low') || rawPrio.includes('backlog') || rawPrio.includes('фон')) priority = '2'
+	else if (rawPrio.includes('p3')) priority = '3'
+	else if (rawPrio.includes('p1') || rawPrio.includes('med')) priority = '1'
+	else if (daysRemaining !== null) {
+		if (daysRemaining <= 3) priority = '0'
+		else if (daysRemaining <= 7) priority = '1'
+		else priority = '2'
+	}
+	return normalizePriority(priority)
+}
+
+/**
+ * Sort tasks by criteria ('priority', 'status', 'alphabetical')
+ * @param {TaskItem[]} [tasks=[]]
+ * @param {'priority' | 'status' | 'alphabetical'} [criteria='priority']
+ * @returns {TaskItem[]}
+ */
+export function sortTasks(tasks = [], criteria = 'priority') {
+	const list = [...tasks]
+	if (criteria === 'priority') {
+		return list.sort((a, b) => parseInt(normalizePriority(a.priority), 10) - parseInt(normalizePriority(b.priority), 10))
+	}
+	if (criteria === 'status') {
+		const weight = { Todo: 0, InProgress: 1, Done: 2 }
+		return list.sort((a, b) => (weight[a.status] ?? 99) - (weight[b.status] ?? 99))
+	}
+	if (criteria === 'alphabetical') {
+		return list.sort((a, b) => (a.content || '').localeCompare(b.content || ''))
+	}
+	return list
+}
+
+/**
+ * Determine release status ('wip' | 'closed' | 'unknown')
+ * @param {object} params
+ * @returns {'wip' | 'closed' | 'unknown'}
+ */
+export function determineReleaseStatus({ fmStatus = '', hasSpec = false, hasTest = false, tasks = [], userStr = '', metrics = { hours: 0, rrs: 0 } } = {}) {
+	const s = (fmStatus || '').toLowerCase()
+	if (s === 'active' || s === 'wip') return 'wip'
+	if (s === 'closed' || s === 'done' || s === 'sealed' || hasTest) return 'closed'
+	if (hasSpec) return 'wip'
+	if (tasks.length > 0) return tasks.every((t) => t.status === 'Done') ? 'closed' : 'wip'
+	if (userStr.includes('status: active') || userStr.includes('status: wip')) return 'wip'
+	if (userStr.includes('status: closed') || userStr.includes('status: done')) return 'closed'
+	if (metrics.hours > 0 || metrics.rrs > 0 || userStr.length > 0) return 'wip'
+	return 'unknown'
+}

package/src/domain/Dashboard/index.js

@@ -0,0 +1,19 @@
+export { DashboardModel } from './DashboardModel.js'
+export {
+	parseFrontmatter,
+	extractTasks,
+	calculateDaysRemaining,
+	parseUserMetrics,
+	normalizePriority,
+	resolvePriority,
+	sortTasks,
+	determineReleaseStatus,
+} from './ReleaseParser.js'
+export {
+	parseSemver,
+	compareSemverDesc,
+	versionToPath,
+	documentExists,
+	loadReleaseDoc,
+	discoverReleases,
+} from './ReleaseDiscovery.js'

package/src/domain/DepsCommand.js

@@ -2,6 +2,11 @@ import { ModelAsApp, result, show } from '@nan0web/ui'
 import { runSpawn } from '@nan0web/test'
 
 export default class DepsCommand extends ModelAsApp {
+	/** @type {boolean} Apply fixes automatically */
+	fix = false
+	/** @type {boolean} Update packages to the latest available versions */
+	latest = false
+
 	static fix = {
 		help: 'Apply fixes automatically',
 		default: false,
@@ -21,8 +26,6 @@ export default class DepsCommand extends ModelAsApp {
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {boolean} Apply fixes automatically */ this.fix
-		/** @type {boolean} Update packages to the latest available versions */ this.latest
 	}
 
 	/**

package/src/domain/InitCommand.js

@@ -1,6 +1,9 @@
 import { ModelAsApp, result, show } from '@nan0web/ui'
 
 export default class InitCommand extends ModelAsApp {
+	/** @type {string} Release version */
+	version = ''
+
 	static version = {
 		help: 'Release version',
 		default: '',
@@ -17,7 +20,6 @@ export default class InitCommand extends ModelAsApp {
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {string} Release version */ this.version
 	}
 
 	/**
@@ -25,8 +27,11 @@ export default class InitCommand extends ModelAsApp {
 	 */
 	async *run() {
 		const { t, db } = this._
+		if (!db) {
+			throw new Error('Database instance ({ db }) is required in InitCommand')
+		}
 		if (!this.version) {
-			throw new Error(t(InitCommand.version.errorRequired))
+			throw new Error(t ? t(InitCommand.version.errorRequired) : InitCommand.version.errorRequired)
 		}
 		const v = this.version.startsWith('v') ? this.version : `v${this.version}`
 
@@ -34,24 +39,21 @@ export default class InitCommand extends ModelAsApp {
 		const major = parts[0] || '0'
 		const minor = parts[1] || '0'
 
-		const { mkdirSync, writeFileSync } = await import('node:fs')
-		const { join } = await import('node:path')
-
-		const dir = join(process.cwd(), 'releases', major, minor, v)
-		mkdirSync(dir, { recursive: true })
+		const taskPath = `releases/${major}/${minor}/${v}/task.md`
+		await db.saveDocument(taskPath, `# Release ${v}\n\n- [ ] Task 1\n`)
 
-		const taskPath = join(dir, 'task.md')
-		writeFileSync(taskPath, `# Release ${v}\n\n- [ ] Task 1`, 'utf8')
-
-		const specPath = join(dir, 'test.spec.js')
-		writeFileSync(
+		const specPath = `releases/${major}/${minor}/${v}/task.spec.js`
+		await db.saveDocument(
 			specPath,
-			`import test from 'node:test'\nimport assert from 'node:assert'\n\ntest('Sample spec', () => {\n\tassert.ok(true)\n})\n`,
-			'utf8',
+			`import test from 'node:test'\nimport assert from 'node:assert'\n\ntest('Release ${v} Specification', () => {\n\tassert.ok(true)\n})\n`,
 		)
 
-		yield show(`✅ Initialized release ${v} in ${dir}`, 'success')
+		yield show(`✅ Initialized release ${v} in releases/${major}/${minor}/${v}`, 'success')
 
-		return result({})
+		return result({
+			version: v,
+			taskPath,
+			specPath,
+		})
 	}
 }

package/src/domain/ListCommand.js

@@ -0,0 +1,45 @@
+import { ModelAsApp, show, result } from '@nan0web/ui'
+import Scanner from '../Release/Scanner.js'
+
+/**
+ * ListCommand - ModelAsApp Subcommand to list all available releases in chronological order.
+ */
+export default class ListCommand extends ModelAsApp {
+	static alias = 'list'
+
+	static UI = {
+		title: 'list',
+		help: 'List all available release versions',
+		noReleases: 'No releases found.',
+	}
+
+	/**
+	 * @param {Partial<ListCommand>} [data]
+	 * @param {import('@nan0web/types').ModelOptions} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+	}
+
+	async *run() {
+		const targetDir = process.env.RELEASE_CWD || process.env.INIT_CWD || process.cwd()
+		const scanner = new Scanner(targetDir)
+		const statuses = scanner.status()
+
+		if (!statuses.length) {
+			yield show(ListCommand.UI.noReleases, 'warn')
+			return result({ versions: [] })
+		}
+
+		// Sort SemVer descending (newest first)
+		const sorted = [...statuses].sort((a, b) => b.version.localeCompare(a.version, undefined, { numeric: true }))
+
+		for (const item of sorted) {
+			yield show(item.version)
+		}
+
+		return result({ versions: sorted.map((s) => s.version) })
+	}
+}
+
+export { ListCommand }

package/src/domain/PreviewCommand.js

@@ -0,0 +1,39 @@
+import WebCommand from './WebCommand.js'
+
+/**
+ * PreviewCommand - ModelAsApp Subcommand to generate, serve and preview PM-as-Code Web Dashboard.
+ */
+export default class PreviewCommand extends WebCommand {
+	static alias = 'preview'
+
+	static UI = {
+		title: 'preview',
+		help: 'Generate, serve and preview PM-as-Code Web Dashboard',
+		loading: 'Aggregating release telemetry and preparing Web Dashboard preview...',
+		generated: '✨ Web Dashboard успішно згенеровано: {$path}',
+		serving: '🌐 Web Dashboard запущено: http://localhost:{$port} (Натисніть Ctrl+C для зупинки)',
+	}
+
+	static port = {
+		help: 'Port to serve HTML dashboard over HTTP',
+		default: 3333,
+		type: 'number',
+		alias: 'p',
+	}
+
+	static open = {
+		help: 'Automatically open in browser',
+		default: true,
+		type: 'boolean',
+	}
+
+	/**
+	 * @param {Partial<PreviewCommand>} [data]
+	 * @param {import('@nan0web/types').ModelOptions} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super({ port: 3333, open: true, ...data }, options)
+	}
+}
+
+export { PreviewCommand }

package/src/domain/PublishCommand.js

@@ -2,6 +2,13 @@ import { ModelAsApp, result, show } from '@nan0web/ui'
 import { runSpawn } from '@nan0web/test'
 
 export default class PublishCommand extends ModelAsApp {
+	/** @type {boolean} Bump major version */
+	major = false
+	/** @type {boolean} Bump minor version */
+	minor = false
+	/** @type {boolean} Bump patch version */
+	patch = false
+
 	static major = {
 		help: 'Bump major version',
 		default: false,
@@ -25,9 +32,6 @@ export default class PublishCommand extends ModelAsApp {
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {boolean} Bump major version */ this.major
-		/** @type {boolean} Bump minor version */ this.minor
-		/** @type {boolean} Bump patch version */ this.patch
 	}
 
 	/**

package/src/domain/Registry/Registry.story.js

@@ -0,0 +1,82 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import DB from '@nan0web/db'
+import { RegistryModel } from './RegistryModel.js'
+
+describe('RegistryModel OLMUI Scenario', () => {
+	it('parses releases.txt and extracts valid project paths ignoring comments and empty lines', async () => {
+		const rawContent = `# Global Registry
+.
+# packages
+packages/release
+
+# apps
+apps/release.app
+apps/3rdparty/industrialbank/bank
+`
+		const db = new DB({
+			predefined: [
+				['releases.txt', rawContent],
+				['package.json', { name: '@nan0web/monorepo', version: '1.0.0' }],
+				['packages/release/package.json', { name: '@nan0web/release', version: '3.3.0' }],
+				['apps/release.app/package.json', { name: 'release.app', version: '0.1.0' }],
+				['apps/3rdparty/industrialbank/bank/package.json', { name: '@industrialbank/bank', version: '3.3.0' }],
+			],
+		})
+		await db.connect()
+
+		const registry = new RegistryModel({ filePath: 'releases.txt' }, { db })
+		const projects = await registry.loadProjects()
+
+		assert.equal(projects.length, 4)
+		assert.deepEqual(projects[0], {
+			path: '.',
+			name: '@nan0web/monorepo',
+			version: '1.0.0',
+		})
+		assert.deepEqual(projects[1], {
+			path: 'packages/release',
+			name: '@nan0web/release',
+			version: '3.3.0',
+		})
+		assert.deepEqual(projects[2], {
+			path: 'apps/release.app',
+			name: 'release.app',
+			version: '0.1.0',
+		})
+		assert.deepEqual(projects[3], {
+			path: 'apps/3rdparty/industrialbank/bank',
+			name: '@industrialbank/bank',
+			version: '3.3.0',
+		})
+	})
+
+	it('handles projects without package.json gracefully', async () => {
+		const db = new DB({
+			predefined: [
+				['releases.txt', 'packages/custom-pkg\n'],
+			],
+		})
+		await db.connect()
+
+		const registry = new RegistryModel({ filePath: 'releases.txt' }, { db })
+		const projects = await registry.loadProjects()
+
+		assert.equal(projects.length, 1)
+		assert.equal(projects[0].name, 'packages/custom-pkg')
+		assert.equal(projects[0].version, '0.0.0')
+	})
+
+	it('parses raw text paths via static parsePaths utility', () => {
+		const text = `
+# Comment 1
+/path/one
+  
+/path/two # inline comment
+# Comment 2
+/path/three
+`
+		const paths = RegistryModel.parsePaths(text)
+		assert.deepEqual(paths, ['/path/one', '/path/two', '/path/three'])
+	})
+})