@nan0web/release 1.0.0

package/src/Release/Document.js

@@ -0,0 +1,110 @@
+import Markdown, { MDElement, MDHeading1, MDHeading2, MDHeading3 } from "@nan0web/markdown"
+import Person from "./Person.js"
+
+class ReleaseDocument extends Markdown {
+	/** @type {Person[]} */
+	team
+	/** @type {Map<string, Person[]>} */
+	roles
+	/** @type {string} */
+	version
+	/** @type {Date | undefined} */
+	date
+
+	/**
+	 * @param {Object} options
+	 * @param {Array} [options.team] - Release team members
+	 * @param {Map | Array} [options.roles] - Release roles map with team members
+	 * @param {string} [options.version] - Release version
+	 * @param {string} [options.date] - Release date
+	 */
+	constructor(options = {}) {
+		super()
+		const {
+			team = [],
+			roles = new Map(),
+			version = "",
+			date
+		} = options
+		this.version = String(version)
+		this.date = date ? new Date(date) : undefined
+		this.team = team.map(t => Person.from(t))
+		this.roles = new Map(roles)
+	}
+
+	/**
+	 * Parse release document content
+	 * Extracts version and date from H1 heading
+	 * @param {string} input - Markdown content
+	 * @returns {MDElement[]}
+	 */
+	parse(input) {
+		const result = super.parse(input)
+
+		const h1s = this.document.filter((el) => el instanceof MDHeading1)
+		if (h1s.length !== 1) {
+			throw new TypeError("Release document must have exactly one H1 heading with version and date")
+		}
+
+		const h1Content = h1s[0].content ?? ""
+		const [versionPart, ...dateParts] = h1Content.split(" - ")
+		this.version = versionPart.trim()
+		this.date = new Date(dateParts.join(" - ").trim())
+
+		const sections = []
+		/** @type {{title: string, tasks: Array} | null} */
+		let currentSection = null
+		for (const el of result) {
+			if (el instanceof MDHeading2) {
+				currentSection = {
+					title: el.content.trim(),
+					tasks: []
+				}
+				sections.push(currentSection)
+			}
+			else if (el instanceof MDHeading3 && currentSection) {
+				const content = el.content.trim()
+				const statusMatch = content.match(/^(\w+)\s*(.+)$/)
+				const slugMatch = content.match(/\[([^\]]+)\]$/)
+
+				let status = 'todo'
+				let taskContent = content
+				let slug = ''
+
+				if (statusMatch) {
+					status = statusMatch[1]
+					taskContent = statusMatch[2]
+				}
+
+				if (slugMatch) {
+					slug = slugMatch[1]
+					taskContent = taskContent.replace(/\[([^\]]+)\]$/, '').trim()
+				}
+
+				currentSection.tasks.push({
+					content: taskContent,
+					status: status,
+					slug: slug
+				})
+			}
+		}
+
+		return result
+	}
+
+	/**
+	 * @param {*} input
+	 * @returns {ReleaseDocument}
+	 */
+	static from(input) {
+		if (input instanceof ReleaseDocument) return input
+		if (typeof input === "string") {
+			const doc = new ReleaseDocument()
+			doc.parse(input)
+			return doc
+		}
+		return new ReleaseDocument(input)
+	}
+}
+
+export default ReleaseDocument

package/src/Release/MarkdownToTest.js

@@ -0,0 +1,137 @@
+/**
+ * MarkdownToTest - generates node:test code from markdown release notes
+ * Enables writing release notes first, then generating executable tests
+ */
+class MarkdownToTest {
+	/**
+	 * Convert markdown release notes to node:test code
+	 * @param {string} markdown - Release notes markdown content
+	 * @returns {string} Generated test code
+	 */
+	generateTests(markdown) {
+		const lines = markdown.split('\n')
+		const versionMatch = markdown.match(/^#\s+(v[\d.]+)\s*-\s*(\d{4}-\d{2}-\d{2})/)
+		
+		if (!versionMatch) {
+			throw new Error('Markdown must start with version header: # vX.Y.Z - YYYY-MM-DD')
+		}
+		
+		const [, version, date] = versionMatch
+		let testCode = this.generateImports()
+		testCode += this.generateDescribeHeader(version, date)
+		
+		const sections = this.extractSections(lines)
+		testCode += this.generateSectionTests(sections)
+		
+		testCode += '})\n'
+		return testCode
+	}
+	
+	/**
+	 * Generate import statements for node:test
+	 * @returns {string} Import code
+	 */
+	generateImports() {
+		return `import { describe, it } from "node:test"
+import { ok, strictEqual } from "node:assert"
+
+`
+	}
+	
+	/**
+	 * Generate main describe block header
+	 * @param {string} version - Release version
+	 * @param {string} date - Release date
+	 * @returns {string} Describe header code
+	 */
+	generateDescribeHeader(version, date) {
+		return `describe("${version} - ${date}", () => {
+`
+	}
+	
+	/**
+	 * Extract sections from markdown lines
+	 * @param {string[]} lines - Markdown lines
+	 * @returns {Array<{title: string, tasks: Array<{content: string, status: string, slug: string}>}>} Sections with tasks
+	 */
+	extractSections(lines) {
+		/** @type {Array<{title: string, tasks: Array<{content: string, status: string, slug: string}>}>} */
+		const sections = []
+		/** @type {{title: string, tasks: Array<{content: string, status: string, slug: string}>} | null} */
+		let currentSection = null
+		
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i]
+			
+			// H2 section
+			if (line.startsWith('## ')) {
+				currentSection = {
+					title: line.slice(3).trim(),
+					tasks: /** @type {Array<{content: string, status: string, slug: string}>} */([])
+				}
+				sections.push(currentSection)
+				continue
+			}
+			
+			// H3 task
+			if (line.startsWith('###') && currentSection) {
+				const statusMatch = line.match(/^###( Draft| InProgress)? \*\*(.+)\*\* \[(.+)\]$/)
+				if (statusMatch) {
+					const [, status, content, slug] = statusMatch
+					currentSection.tasks.push({
+						content,
+						status: status ? status.trim() : 'Done',
+						slug
+					})
+				}
+				continue
+			}
+		}
+		
+		return sections
+	}
+	
+	/**
+	 * Generate test code for sections and their tasks
+	 * @param {Array<{title: string, tasks: Array}>} sections - Sections with tasks
+	 * @returns {string} Generated test code
+	 */
+	generateSectionTests(sections) {
+		let code = ''
+		
+		sections.forEach(section => {
+			code += `	describe("${section.title}", () => {
+`
+			
+			section.tasks.forEach(/** @param {{status: string, content: string}} task */task => {
+				switch (task.status) {
+					case 'Draft':
+						code += `		it.todo("${task.content}", () => {
+			ok(false, "Draft task - not yet implemented")
+		})
+`
+						break
+					case 'InProgress':
+						code += `		it.skip("${task.content}", () => {
+			ok(false, "In progress task - not yet completed")
+		})
+`
+						break
+					default: // Done
+						code += `		it("${task.content}", () => {
+			ok(true, "Task completed successfully")
+		})
+`
+						break
+				}
+			})
+			
+			code += `	})
+`
+		})
+		
+		return code
+	}
+}
+
+export default MarkdownToTest

package/src/Release/MarkdownToTest.test.js

@@ -0,0 +1,60 @@
+import { describe, it } from "node:test"
+import { strictEqual } from "node:assert"
+import MarkdownToTest from "./MarkdownToTest.js"
+
+describe.skip("MarkdownToTest", () => {
+	it("should generate node:test code from markdown release notes", () => {
+		const parser = new MarkdownToTest()
+		const markdown = `# v1.1.0 - 2025-08-19
+
+## CLI application
+###  **Treats project management like code: everything is versioned, auditable, reversible.** [treats-project-management-like-code-everything-is-versioned-auditable-reversible]
+### Draft **No external tools or databases needed — just Git.** [no-external-tools-or-databases-needed-just-git]
+###  **Natural for developers; lowers barrier to entry for dev-centric teams.** [natural-for-developers-lowers-barrier-to-entry-for-dev-centric-teams]
+
+## UI application
+###  **Drag-and-drop interface** [drag-and-drop-interface]
+###  **Visual tree structure** [visual-tree-structure]`
+
+		const expected = `import { describe, it } from "node:test"
+import { ok, strictEqual } from "node:assert"
+
+describe("v1.1.0 - 2025-08-19", () => {
+	describe("CLI application", () => {
+		it("Treats project management like code: everything is versioned, auditable, reversible.", () => {
+			ok(true, "Task completed successfully")
+		})
+		it.skip("No external tools or databases needed — just Git.", () => {
+			ok(false, "Draft task - not yet implemented")
+		})
+		it("Natural for developers; lowers barrier to entry for dev-centric teams.", () => {
+			ok(true, "Task completed successfully")
+		})
+	})
+	describe("UI application", () => {
+		it("Drag-and-drop interface", () => {
+			ok(true, "Task completed successfully")
+		})
+		it("Visual tree structure", () => {
+			ok(true, "Task completed successfully")
+		})
+	})
+})`
+
+		const result = parser.generateTests(markdown)
+		strictEqual(result.trim(), expected.trim())
+	})
+
+	it("should throw error if markdown doesn't have version header", () => {
+		const parser = new MarkdownToTest()
+		const markdown = `## CLI application
+###  **Treats project management like code** [treats-project-management-like-code]`
+
+		try {
+			parser.generateTests(markdown)
+			throw new Error("Should have thrown an error")
+		} catch (error) {
+			strictEqual(error.message, 'Markdown must start with version header: # vX.Y.Z - YYYY-MM-DD')
+		}
+	})
+})

package/src/Release/Person.js

@@ -0,0 +1,29 @@
+import { HumanName, HumanContact, HumanGender } from "@nan0web/verse"
+
+export default class Person {
+	/** @type {HumanName} */
+	name
+	/** @type {HumanGender} */
+	gender
+	/** @type {HumanContact[]} */
+	contacts
+	constructor(input = {}) {
+		const {
+			name = new HumanName([]),
+			gender = new HumanGender(-1),
+			contacts = []
+		} = input
+		this.name = HumanName.from(name)
+		this.gender = HumanGender.from(gender)
+		this.contacts = contacts.map(c => HumanContact.from(c))
+	}
+	/**
+	 * @param {*} input
+	 * @returns {Person}
+	 */
+	static from(input) {
+		if (input instanceof Person) return input
+		return new Person(input)
+	}
+}
+

package/src/Release.js

@@ -0,0 +1,132 @@
+import ReleaseDocument from "./Release/Document.js"
+import Logger from '@nan0web/log'
+
+/**
+ * @typedef {Object} ReleaseConfig
+ * @property {string} [version] - Release version
+ * @property {string | number | Date | undefined} [createdAt] -
+ * @property {string | number | Date | undefined} [startAt] -
+ * @property {string | number | Date | undefined} [planAt] -
+ * @property {string | number | Date | undefined} [completeAt] -
+ * @property {string | ReleaseDocument} [document] -
+ * @property {Map<string, Function>} [tasks] - Task map with test functions
+ */
+
+/**
+ * Release management class that coordinates task validation and release execution
+ */
+class Release {
+	/** @type {string} */
+	version
+	/** @type {Date} */
+	createdAt
+	/** @type {Date?} */
+	startAt
+	/** @type {Date?} */
+	planAt
+	/** @type {Date?} */
+	completeAt
+	/** @type {Map<string, Function>} */
+	tasks
+	/** @type {ReleaseDocument} */
+	document
+	/** @type {Logger} */
+	logger
+
+	/**
+	 * Creates a Release instance
+	 * @param {ReleaseConfig} config - Release configuration
+	 */
+	constructor(config = {}) {
+		const {
+			version = '0.0.0',
+			createdAt = new Date(),
+			startAt,
+			planAt,
+			completeAt,
+			document,
+			tasks = new Map()
+		} = config
+
+		this.version = String(version)
+		this.createdAt = new Date(createdAt)
+		this.startAt = startAt ? new Date(startAt) : null
+		this.planAt = planAt ? new Date(planAt) : null
+		this.completeAt = completeAt ? new Date(completeAt) : null
+		this.document = ReleaseDocument.from(document)
+		this.tasks = tasks
+		this.logger = new Logger()
+	}
+
+	get path() {
+		return [...this.version.replace("v", "").split(".").slice(0, 2), this.version].join("/")
+	}
+
+	/**
+	 * Validate release by running all task tests
+	 * @returns {Promise<Object>} Validation results
+	 */
+	async validate() {
+		const results = {
+			passed: /** @type {Array} */([]),
+			failed: /** @type {Array<{taskId: any, error: string}>} */([]),
+			pending: /** @type {Array} */([])
+		}
+
+		for (const [taskId, testFn] of this.tasks.entries()) {
+			try {
+				await testFn()
+				results.passed.push(taskId)
+			} catch (error) {
+				results.failed.push({ taskId, error: /** @type {Error} */(error).message })
+			}
+		}
+
+		return results
+	}
+
+	/**
+	 * Execute release process
+	 * @param {Object} options - Release options
+	 * @param {boolean} [options.ignoreFailTests=false] - Ignore failed tests
+	 * @returns {Promise<boolean>} Release success status
+	 */
+	async execute(options = {}) {
+		const { ignoreFailTests = false } = options
+		const validation = await this.validate()
+
+		if (!ignoreFailTests && validation.failed.length > 0) {
+			this.logger.error(`Release blocked: ${validation.failed.length} tasks failed`)
+			for (const failure of validation.failed) {
+				this.logger.error(`  ${failure.taskId}: ${failure.error}`)
+			}
+			return false
+		}
+
+		this.logger.info(`Release ${this.version} executed successfully`)
+		return true
+	}
+
+	/**
+	 * Get release progress statistics
+	 * @returns {Promise<Object>} Progress statistics
+	 */
+	async getProgress() {
+		const validation = await this.validate()
+		const totalTasks = this.tasks.size
+		const completedTasks = validation.passed.length
+		const failedTasks = validation.failed.length
+		const pendingTasks = validation.pending.length
+
+		return {
+			version: this.version,
+			total: totalTasks,
+			completed: completedTasks,
+			failed: failedTasks,
+			pending: pendingTasks,
+			progress: totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0
+		}
+	}
+}
+
+export default Release

package/src/ReleaseCLI.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+import { Command } from '@nan0web/co'
+import Logger from '@nan0web/log'
+import FS from "@nan0web/db-fs"
+import DB from "./db/ReleaseDB.js"
+import Release from './Release.js'
+import ChatCommand from './commands/ChatCommand.js'
+import HostCommand from './commands/HostCommand.js'
+import InitCommand from './commands/InitCommand.js'
+import ListCommand from './commands/ListCommand.js'
+import SealCommand from './commands/SealCommand.js'
+import ServeCommand from './commands/ServeCommand.js'
+import ShowCommand from './commands/ShowCommand.js'
+import AppCommandMessage from './co/AppCommandMessage.js'
+
+/**
+ * CLI application for release management
+ */
+export default class ReleaseCLI extends Command {
+	static Message = AppCommandMessage
+	/** @type {Logger} */
+	logger
+	/** @type {DB?} */
+	db
+	/** @type {FS} */
+	fs
+	/** @type {Record<string, Release>} */
+	releases = {}
+	/** @type {Release?} */
+	current = null
+
+	constructor() {
+		super({
+			name: 'release',
+			help: 'Release management CLI tool'
+		})
+		this.logger = new Logger({ icons: true })
+		this.fs = new FS()
+		this.db = null
+		this.addOption('releaseDir', String, '.', 'Release dir')
+		this.addOption('version', String, '0.0.0', 'Release version')
+	}
+
+	/**
+	 * @param {string[] | string} argv
+	 * @returns {AppCommandMessage}
+	 */
+	parse(argv = []) {
+		return AppCommandMessage.from(super.parse(argv))
+	}
+
+	/**
+	 * Run CLI application
+	 * @param {string[]} argv - Command line arguments
+	 * @returns {Promise<void>}
+	 */
+	async run(argv) {
+		const msg = this.parse(argv)
+		await this.fs.connect()
+
+		const rootDb = this.fs.extract(/** @type {string} */(msg.opts.releaseDir))
+
+		const indexStat = await rootDb.statDocument("index.js")
+		const currentStat = await rootDb.statDocument("current.js")
+		if (indexStat.exists && currentStat.exists) {
+			const indexJs = rootDb.absolute("index.js")
+			const currentJs = rootDb.absolute("current.js")
+			try {
+				this.releases = (await import(indexJs)).default
+				this.current = (await import(currentJs)).default
+				this.logger.info(Object.keys(this.releases).length, "release(s) found")
+			} catch (e) {
+				this.logger.error("Failed to load release database", e)
+				this.current = null
+			}
+		} else {
+			this.logger.info("No releases initialized. Use 'release init <version>' to create your first release.")
+		}
+
+		const globalOpts = { logger: this.logger }
+		this.addSubcommand(new ListCommand(globalOpts))
+		this.addSubcommand(new HostCommand(globalOpts))
+		this.addSubcommand(new ServeCommand(globalOpts))
+
+		if (this.current) {
+			this.logger.info("Current release", this.current.version)
+			this.db = DB.from(rootDb.extract(this.current.path))
+			await this.db.connect()
+			const document = await this.db.loadDocument("release.md")
+			const release = new Release({ document, version: this.current.version })
+			const currentOpts = { ...globalOpts, db: this.db }
+			this.addSubcommand(new InitCommand(currentOpts))
+			this.addSubcommand(new ShowCommand(currentOpts))
+			this.addSubcommand(new ChatCommand(currentOpts))
+			this.addSubcommand(new SealCommand(currentOpts))
+		}
+		else {
+			this.logger.info("Provide a release version")
+			this.logger.info(this.generateHelp())
+		}
+		return
+	}
+
+	async loadReleaseFiles() {
+		if (!this.db) return
+		const stream = this.db.findStream("")
+		const started = Date.now()
+		for await (const entry of stream) {
+			const spent = ((Date.now() - started) / 1000).toFixed(3)
+			this.logger.clearLine(this.logger.cursorUp())
+			this.logger.info("Loading ..", spent + "s", this.db.data.size, entry.file.path)
+		}
+		const spent = ((Date.now() - started) / 1000).toFixed(3)
+		this.logger.clearLine(this.logger.cursorUp(/** @type {DB} */(this.db).data.size & 1))
+		const info = [
+			["Loaded in", spent + "s", /** @type {DB} */(this.db).data.size, "document(s)"],
+			["", "", /** @type {DB} */(this.db).releases.length, "release(s)"],
+		]
+		this.logger.table(info, [], { padding: 1 })
+	}
+}

package/src/Team.js

@@ -0,0 +1,35 @@
+import { HumanName, HumanGender, HumanContact } from "@nan0web/verse"
+
+class Person {
+	/** @type {HumanName} */
+	name
+	/** @type {HumanGender} */
+	gender
+	/** @type {HumanContact[]} */
+	contacts
+	
+	constructor(name) {
+		this.name = new HumanName(name)
+		this.gender = new HumanGender(-1)
+		this.contacts = []
+	}
+}
+
+class CLevelTeam {
+	static name = "C Level"
+	static ceo = new Person(["Yaroslav", "Wise"])
+	static cfo = new Person(["Chingis"])
+}
+
+class UXTeam {
+	static name = "UX"
+	static designer = new Person(["Taras", "Shevchenko"])
+}
+
+class Company {
+	static name = "NaN•Web"
+	static c = CLevelTeam
+	static ux = UXTeam
+}
+
+export default Company