@nan0web/release 3.3.0 → 3.5.0

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'])
+	})
+})

package/src/domain/Registry/RegistryModel.js

@@ -0,0 +1,124 @@
+import { Model } from '@nan0web/types'
+
+/**
+ * @typedef {Object} ProjectEntry
+ * @property {string} path - Project relative or absolute path
+ * @property {string} name - Package name from package.json or folder basename
+ * @property {string} version - Package version from package.json
+ */
+
+/**
+ * RegistryModel - PM-as-Code Project Registry manager.
+ * Reads project paths from releases.txt and discovers package metadata.
+ */
+export class RegistryModel extends Model {
+	static filePath = {
+		help: 'Path to releases.txt registry file',
+		default: 'releases.txt',
+		type: 'string',
+	}
+
+	static projects = {
+		help: 'List of registered projects',
+		default: () => [],
+		type: 'array',
+	}
+
+	static UI = {
+		fileNotFound: 'Registry file {$path} not found',
+		loadingProjects: 'Loading projects from registry {$path}...',
+		projectsLoaded: 'Loaded {$count} projects from registry',
+	}
+
+	/**
+	 * @param {Partial<RegistryModel>} [data]
+	 * @param {import('@nan0web/types').ModelOptions} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+		/** @type {string} Path to registry file */ this.filePath
+		/** @type {ProjectEntry[]} List of registered projects */ this.projects
+	}
+
+	/**
+	 * Parse raw content of releases.txt into array of clean paths
+	 * @param {string} content
+	 * @returns {string[]}
+	 */
+	static parsePaths(content = '') {
+		if (typeof content !== 'string') return []
+		return content
+			.split('\n')
+			.map((line) => {
+				// Strip comments starting with #
+				const withoutComment = line.split('#')[0]
+				return withoutComment.trim()
+			})
+			.filter((line) => line.length > 0)
+	}
+
+	/**
+	 * Load project entries from registry file using injected DB instance
+	 * @returns {Promise<ProjectEntry[]>}
+	 */
+	async loadProjects() {
+		const db = this._.db
+		if (!db) {
+			throw new Error('Database instance is required in options ({ db }) to load projects')
+		}
+
+		let content = await db.loadDocument(this.filePath, '')
+		let rootPrefix = ''
+		if (!content && this.filePath === 'releases.txt') {
+			try {
+				const parent2 = await db.loadDocument('../../releases.txt', '')
+				if (parent2) {
+					content = parent2
+					rootPrefix = '../../'
+				} else {
+					const parent1 = await db.loadDocument('../releases.txt', '')
+					if (parent1) {
+						content = parent1
+						rootPrefix = '../'
+					}
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		const paths = RegistryModel.parsePaths(String(content || ''))
+
+		/** @type {ProjectEntry[]} */
+		const result = []
+
+		for (const projectPath of paths) {
+			const effectivePath = rootPrefix
+				? projectPath === '.'
+					? rootPrefix.slice(0, -1)
+					: `${rootPrefix}${projectPath}`
+				: projectPath
+			const pkgPath = effectivePath === '.' ? 'package.json' : `${effectivePath.replace(/\/+$/, '')}/package.json`
+			let pkg = null
+			try {
+				pkg = await db.loadDocument(pkgPath, null)
+			} catch {
+				pkg = null
+			}
+
+			const name = pkg?.name || projectPath
+			const version = pkg?.version || '0.0.0'
+
+			result.push({
+				path: projectPath,
+				name,
+				version,
+			})
+		}
+
+		this.projects = result
+		return result
+	}
+}
+
+export default RegistryModel

package/src/domain/ServeCommand.js

@@ -0,0 +1,165 @@
+import { ModelAsApp, result, show } from '@nan0web/ui'
+import Markdown from '@nan0web/markdown'
+import DEFAULT_TEMPLATE from './templates/release.html.template.js'
+
+/**
+ * ServeCommand - Universal ModelAsApp for data or release catalogs.
+ *
+ * Generates HTML content from README.md and release templates using $db and Markdown.
+ * Pure OLMUI model: does not start HTTP server, does not call node:fs or child_process.
+ *
+ * Usage:
+ *   pnpm exec serve releases/  # Runs via CLI bootstrap
+ */
+export default class ServeCommand extends ModelAsApp {
+	static alias = 'serve'
+
+	static UI = {
+		title: 'serve',
+		help: 'Serve data or releases catalog over HTTP',
+		serving: '🌐 Serving {$dir} on http://localhost:{$port} (Press Ctrl+C to stop)',
+		dirNotFound: 'Directory {$dir} does not exist.',
+	}
+
+	static dir = {
+		help: 'Directory to serve (e.g. releases/ or data/)',
+		positional: true,
+		type: 'string',
+		default: 'releases',
+	}
+
+	static port = {
+		help: 'HTTP server port',
+		default: 3131,
+		type: 'number',
+		alias: 'p',
+	}
+
+	static open = {
+		help: 'Automatically open in browser',
+		default: true,
+		type: 'boolean',
+	}
+
+	/**
+	 * @param {Partial<ServeCommand>} [data]
+	 * @param {import('@nan0web/types').ModelOptions} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+		/** @type {string} */
+		this.dir = String(data.dir || (options && 'dir' in options ? /** @type {any} */ (options).dir : 'releases'))
+		/** @type {number} */
+		this.port = Number(data.port ?? (options && 'port' in options ? /** @type {any} */ (options).port : 3131))
+		/** @type {boolean} */
+		this.open = Boolean(data.open ?? (options && 'open' in options ? /** @type {any} */ (options).open : true))
+	}
+
+	/**
+	 * Convert markdown string to HTML using @nan0web/markdown
+	 * @param {string} mdRaw
+	 * @returns {string}
+	 */
+	renderMarkdownToHtml(mdRaw) {
+		if (!mdRaw || typeof mdRaw !== 'string') return ''
+		const md = new Markdown(mdRaw)
+		return md.stringify()
+	}
+
+	/**
+	 * Render HTML content for the target directory
+	 * @returns {Promise<string>}
+	 */
+	async renderHtml() {
+		const db = this.$db
+		let readmeContent = ''
+		const readmePath = db.resolveSync ? db.resolveSync(this.dir, 'README.md') : `${this.dir}/README.md`
+
+		try {
+			const mdRaw = await db.loadDocument(readmePath, null)
+			if (mdRaw) {
+				readmeContent = this.renderMarkdownToHtml(typeof mdRaw === 'string' ? mdRaw : mdRaw.content || String(mdRaw))
+			}
+		} catch {}
+
+		if (!readmeContent) {
+			// If no README.md in directory, scan directory entries and list them nicely
+			let listItems = []
+			try {
+				if (typeof db.listDir === 'function') {
+					const entries = await db.listDir(this.dir)
+					if (entries && Array.isArray(entries)) {
+						listItems = entries
+							.map((e) => e?.name || e?.path || String(e))
+							.filter((name) => !name.startsWith('.'))
+					}
+				}
+			} catch {}
+
+			const title = this.dir === 'releases' ? 'Releases Catalog' : `Index of ${this.dir}`
+			let md = `# ${title}\n\n`
+			if (listItems.length > 0) {
+				md += `Found **${listItems.length}** item(s) in \`${this.dir}\`:\n\n`
+				for (const item of listItems) {
+					md += `- **\`${item}\`**\n`
+				}
+			} else {
+				md += `Directory \`${this.dir}\` is currently empty or contains no catalog entries.\n`
+			}
+			readmeContent = this.renderMarkdownToHtml(md)
+		}
+
+		// Load template via DB or fallback to bundled template
+		let templateRaw = null
+		try {
+			templateRaw = await db.loadDocument('packages/release/src/domain/templates/release.html', null)
+		} catch {}
+
+		if (!templateRaw) {
+			templateRaw = DEFAULT_TEMPLATE
+		}
+
+		return String(templateRaw).replace('{{CONTENT}}', readmeContent)
+	}
+
+	async *run() {
+		const db = this.$db
+
+		// Check if directory exists via db.listDir or db.stat
+		let dirExists = false
+		try {
+			if (typeof db.listDir === 'function') {
+				const entries = await db.listDir(this.dir)
+				dirExists = entries && entries.length > 0
+			}
+			if (!dirExists && typeof db.stat === 'function') {
+				const stat = await db.stat(this.dir)
+				dirExists = Boolean(stat && (stat.exists || stat.isDirectory || stat.isFile))
+			}
+		} catch {
+			dirExists = false
+		}
+
+		if (!dirExists) {
+			yield show(ServeCommand.UI.dirNotFound.replace('{$dir}', this.dir), 'error')
+			return result({ success: false })
+		}
+
+		const html = await this.renderHtml()
+
+		yield show(
+			ServeCommand.UI.serving.replace('{$dir}', this.dir).replace('{$port}', String(this.port)),
+			'success'
+		)
+
+		return result({
+			success: true,
+			dir: this.dir,
+			port: this.port,
+			open: this.open,
+			html,
+		})
+	}
+}
+
+export { ServeCommand }

package/src/domain/ServeCommand.story.js

@@ -0,0 +1,88 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import DB from '@nan0web/db'
+import ServeCommand from './ServeCommand.js'
+
+describe('ServeCommand OLMUI Scenario & Model Test', () => {
+	it('generates HTML from releases/README.md when directory exists', async () => {
+		const readmeMd = `# Releases
+
+This is the main catalog of releases.
+
+## Active Projects
+- @nan0web/ui
+- @nan0web/db
+`
+		const templateHtml = `<!DOCTYPE html><html><body><main>{{CONTENT}}</main></body></html>`
+
+		const db = new DB({
+			predefined: [
+				['releases/README.md', readmeMd],
+				['packages/release/src/domain/templates/release.html', templateHtml],
+			],
+		})
+		await db.connect()
+
+		const cmd = new ServeCommand({ dir: 'releases', port: 3131 }, { db })
+		const gen = cmd.run()
+
+		let step = await gen.next()
+		const outputs = []
+		while (!step.done) {
+			outputs.push(step.value)
+			step = await gen.next()
+		}
+
+		const res = step.value?.data || step.value
+		assert.ok(res.success !== false, 'Execution should succeed')
+		assert.equal(res.dir, 'releases')
+		assert.equal(res.port, 3131)
+		assert.ok(typeof res.html === 'string', 'Should return html string')
+		assert.ok(res.html.includes('Releases'), 'HTML should contain rendered markdown title')
+		assert.ok(res.html.includes('main'), 'HTML should use the template')
+	})
+
+	it('yields error when target directory does not exist', async () => {
+		const db = new DB({
+			predefined: [],
+		})
+		await db.connect()
+
+		const cmd = new ServeCommand({ dir: 'nonexistent-dir' }, { db })
+		const gen = cmd.run()
+
+		let step = await gen.next()
+		const outputs = []
+		while (!step.done) {
+			outputs.push(step.value)
+			step = await gen.next()
+		}
+
+		const res = step.value?.data || step.value
+		assert.equal(res.success, false)
+		assert.ok(outputs.some((o) => o?.type === 'show' || o?.tag === 'show' || String(o).includes('Directory') || o?.content?.includes('nonexistent-dir')))
+	})
+
+	it('handles missing README.md with fallback content', async () => {
+		const templateHtml = `<!DOCTYPE html><html><body>{{CONTENT}}</body></html>`
+		const db = new DB({
+			predefined: [
+				['releases/.gitkeep', ''],
+				['packages/release/src/domain/templates/release.html', templateHtml],
+			],
+		})
+		await db.connect()
+
+		const cmd = new ServeCommand({ dir: 'releases' }, { db })
+		const gen = cmd.run()
+
+		let step = await gen.next()
+		while (!step.done) {
+			step = await gen.next()
+		}
+
+		const res = step.value?.data || step.value
+		assert.ok(res.success !== false)
+		assert.ok(res.html.includes('Releases'))
+	})
+})

package/src/domain/SpecCommand.js

@@ -3,6 +3,9 @@ import { runSpawn } from '@nan0web/test'
 import Scanner from '../Release/Scanner.js'
 
 export default class SpecCommand extends ModelAsApp {
+	/** @type {string} Release version filter */
+	version = ''
+
 	static version = {
 		help: 'Release version filter',
 		default: '',
@@ -18,7 +21,6 @@ export default class SpecCommand extends ModelAsApp {
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {string} Release version filter */ this.version
 	}
 
 	/**