@nan0web/release 1.0.1 → 1.0.3

package/src/Release/MarkdownToTest.js

@@ -11,22 +11,22 @@ class MarkdownToTest {
 	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
@@ -37,7 +37,7 @@ import { ok, strictEqual } from "node:assert"
 
 `
 	}
-	
+
 	/**
 	 * Generate main describe block header
 	 * @param {string} version - Release version
@@ -48,7 +48,7 @@ import { ok, strictEqual } from "node:assert"
 		return `describe("${version} - ${date}", () => {
 `
 	}
-	
+
 	/**
 	 * Extract sections from markdown lines
 	 * @param {string[]} lines - Markdown lines
@@ -59,20 +59,20 @@ import { ok, strictEqual } from "node:assert"
 		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}>} */([])
+					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)? \*\*(.+)\*\* \[(.+)\]$/)
@@ -81,16 +81,16 @@ import { ok, strictEqual } from "node:assert"
 					currentSection.tasks.push({
 						content,
 						status: status ? status.trim() : 'Done',
-						slug
+						slug,
 					})
 				}
 				continue
 			}
 		}
-		
+
 		return sections
 	}
-	
+
 	/**
 	 * Generate test code for sections and their tasks
 	 * @param {Array<{title: string, tasks: Array}>} sections - Sections with tasks
@@ -98,40 +98,42 @@ import { ok, strictEqual } from "node:assert"
 	 */
 	generateSectionTests(sections) {
 		let code = ''
-		
-		sections.forEach(section => {
+
+		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}", () => {
+
+			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}", () => {
+							break
+						case 'InProgress':
+							code += `		it.skip("${task.content}", () => {
 			ok(false, "In progress task - not yet completed")
 		})
 `
-						break
-					default: // Done
-						code += `		it("${task.content}", () => {
+							break
+						default: // Done
+							code += `		it("${task.content}", () => {
 			ok(true, "Task completed successfully")
 		})
 `
-						break
-				}
-			})
-			
+							break
+					}
+				},
+			)
+
 			code += `	})
 `
 		})
-		
+
 		return code
 	}
 }
 
-export default MarkdownToTest
+export default MarkdownToTest

package/src/Release/Person.js

@@ -1,4 +1,4 @@
-import { HumanName, HumanContact, HumanGender } from "@nan0web/verse"
+import { HumanName, HumanContact, HumanGender } from '@nan0web/verse'
 
 export default class Person {
 	/** @type {HumanName} */
@@ -8,14 +8,10 @@ export default class Person {
 	/** @type {HumanContact[]} */
 	contacts
 	constructor(input = {}) {
-		const {
-			name = new HumanName([]),
-			gender = new HumanGender(-1),
-			contacts = []
-		} = 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))
+		this.contacts = contacts.map((c) => HumanContact.from(c))
 	}
 	/**
 	 * @param {*} input
@@ -26,4 +22,3 @@ export default class Person {
 		return new Person(input)
 	}
 }
-

package/src/Release/Scanner.js

@@ -0,0 +1,179 @@
+import { readdirSync, existsSync, renameSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+/**
+ * @typedef {Object} ContractEntry
+ * @property {string} version - Release version (e.g. "v1.0.0")
+ * @property {string} path - Absolute path to the contract file
+ * @property {string} type - "spec" or "test"
+ * @property {string} dir - Directory containing the contract
+ */
+
+/**
+ * @typedef {Object} VersionStatus
+ * @property {string} version - Release version
+ * @property {'wip' | 'closed' | 'mixed'} state - Version state
+ * @property {string[]} specs - Paths to spec files
+ * @property {string[]} tests - Paths to test files
+ */
+
+/**
+ * Рекурсивний сканер для пошуку release контрактів.
+ * Підтримує вкладену структуру: releases/{major}/{minor}/v{version}/
+ * та плоску: releases/v{version}/
+ */
+export default class Scanner {
+	/** @type {string} */
+	root
+
+	/**
+	 * @param {string} root - Root directory of the project
+	 */
+	constructor(root) {
+		this.root = resolve(root)
+	}
+
+	/**
+	 * Find all .spec.js files (WIP contracts)
+	 * @param {string} [version] - Optional version filter
+	 * @returns {ContractEntry[]}
+	 */
+	findSpecs(version) {
+		return this.#scan(join(this.root, 'releases'), '.spec.js', version)
+	}
+
+	/**
+	 * Find all .test.js files (Closed contracts)
+	 * @param {string} [version] - Optional version filter
+	 * @returns {ContractEntry[]}
+	 */
+	findTests(version) {
+		const oldTests = this.#scan(join(this.root, 'releases'), '.test.js', version)
+		const newTests = this.#scan(join(this.root, 'src', 'releases'), '.test.js', version)
+		return [...oldTests, ...newTests]
+	}
+
+	/**
+	 * Get status of all versions
+	 * @returns {VersionStatus[]}
+	 */
+	status() {
+		const specs = this.findSpecs()
+		const tests = this.findTests()
+
+		/** @type {Map<string, VersionStatus>} */
+		const map = new Map()
+
+		for (const entry of [...specs, ...tests]) {
+			let status = map.get(entry.version)
+			if (!status) {
+				status = {
+					version: entry.version,
+					state: 'wip',
+					specs: [],
+					tests: [],
+				}
+				map.set(entry.version, status)
+			}
+			if (entry.type === 'spec') status.specs.push(entry.path)
+			else status.tests.push(entry.path)
+		}
+
+		for (const status of map.values()) {
+			if (status.specs.length > 0 && status.tests.length > 0) {
+				status.state = 'mixed'
+			} else if (status.specs.length === 0 && status.tests.length > 0) {
+				status.state = 'closed'
+			} else {
+				status.state = 'wip'
+			}
+		}
+
+		return [...map.values()].sort((a, b) => a.version.localeCompare(b.version))
+	}
+
+	/**
+	 * Close a release: rename all .spec.js → .test.js
+	 * @param {string} [version] - Version to close. If omitted, closes all WIP.
+	 * @returns {{ closed: number, files: string[] }}
+	 */
+	close(version) {
+		const specs = this.findSpecs(version)
+
+		if (version && specs.length === 0) {
+			// Check if the version exists at all (might already be closed)
+			const tests = this.findTests(version)
+			if (tests.length === 0) {
+				throw new Error(`Version ${version} not found in releases/`)
+			}
+			return { closed: 0, files: [] }
+		}
+
+		const files = []
+		for (const spec of specs) {
+			const newPath = spec.path.replace('.spec.js', '.test.js')
+			renameSync(spec.path, newPath)
+			files.push(newPath)
+		}
+
+		return { closed: files.length, files }
+	}
+
+	/**
+	 * Recursively scan directory for contract files
+	 * @param {string} baseDir - Directory to scan
+	 * @param {string} suffix - File suffix (.spec.js or .test.js)
+	 * @param {string} [version] - Optional version filter
+	 * @returns {ContractEntry[]}
+	 */
+	#scan(baseDir, suffix, version) {
+		if (!existsSync(baseDir)) return []
+
+		/** @type {ContractEntry[]} */
+		const results = []
+		this.#walkDir(baseDir, suffix, version, results)
+		return results
+	}
+
+	/**
+	 * @param {string} dir
+	 * @param {string} suffix
+	 * @param {string | undefined} version
+	 * @param {ContractEntry[]} results
+	 */
+	#walkDir(dir, suffix, version, results) {
+		let entries
+		try {
+			entries = readdirSync(dir, { withFileTypes: true })
+		} catch {
+			return
+		}
+
+		// Check if this directory is a version directory (starts with 'v' and has dots)
+		const dirName = dir.split('/').pop() || ''
+		const isVersionDir = /^v\d+\.\d+\.\d+/.test(dirName)
+
+		if (isVersionDir) {
+			if (version && dirName !== version) return
+
+			for (const entry of entries) {
+				if (entry.isFile() && entry.name.endsWith(suffix)) {
+					results.push({
+						version: dirName,
+						path: join(dir, entry.name),
+						type: suffix === '.spec.js' ? 'spec' : 'test',
+						dir,
+					})
+				}
+			}
+			return
+		}
+
+		// Recurse into subdirectories
+		for (const entry of entries) {
+			if (entry.isDirectory() && !entry.name.startsWith('.')) {
+				this.#walkDir(join(dir, entry.name), suffix, version, results)
+			}
+		}
+	}
+}

package/src/Release.js

@@ -1,10 +1,11 @@
-import ReleaseDocument from "./Release/Document.js"
+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} [date] - Alias for createdAt
  * @property {string | number | Date | undefined} [startAt] -
  * @property {string | number | Date | undefined} [planAt] -
  * @property {string | number | Date | undefined} [completeAt] -
@@ -15,7 +16,7 @@ import Logger from '@nan0web/log'
 /**
  * Release management class that coordinates task validation and release execution
  */
-class Release {
+export default class Release {
 	/** @type {string} */
 	version
 	/** @type {Date} */
@@ -40,12 +41,12 @@ class Release {
 	constructor(config = {}) {
 		const {
 			version = '0.0.0',
-			createdAt = new Date(),
+			createdAt = config.date || new Date(),
 			startAt,
 			planAt,
 			completeAt,
 			document,
-			tasks = new Map()
+			tasks = new Map(),
 		} = config
 
 		this.version = String(version)
@@ -56,10 +57,18 @@ class Release {
 		this.document = ReleaseDocument.from(document)
 		this.tasks = tasks
 		this.logger = new Logger()
+
+		// Store additional config properties
+		for (const [key, value] of Object.entries(config)) {
+			if (!(key in this)) {
+				/** @ts-ignore */
+				this[key] = value
+			}
+		}
 	}
 
 	get path() {
-		return [...this.version.replace("v", "").split(".").slice(0, 2), this.version].join("/")
+		return [...this.version.replace('v', '').split('.').slice(0, 2), this.version].join('/')
 	}
 
 	/**
@@ -68,9 +77,9 @@ class Release {
 	 */
 	async validate() {
 		const results = {
-			passed: /** @type {Array} */([]),
-			failed: /** @type {Array<{taskId: any, error: string}>} */([]),
-			pending: /** @type {Array} */([])
+			passed: /** @type {Array} */ ([]),
+			failed: /** @type {Array<{taskId: any, error: string}>} */ ([]),
+			pending: /** @type {Array} */ ([]),
 		}
 
 		for (const [taskId, testFn] of this.tasks.entries()) {
@@ -78,7 +87,7 @@ class Release {
 				await testFn()
 				results.passed.push(taskId)
 			} catch (error) {
-				results.failed.push({ taskId, error: /** @type {Error} */(error).message })
+				results.failed.push({ taskId, error: /** @type {Error} */ (error).message })
 			}
 		}
 
@@ -124,9 +133,7 @@ class Release {
 			completed: completedTasks,
 			failed: failedTasks,
 			pending: pendingTasks,
-			progress: totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0
+			progress: totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0,
 		}
 	}
 }
-
-export default Release

package/src/Team.js

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

package/src/architecture/ProjectManagementAsCode.js

@@ -78,9 +78,9 @@ export class ProjectManagement {
 	 */
 	async validateProjectState() {
 		const results = {
-			passed: /** @type {string[]} */([]),
-			failed: /** @type {string[]} */([]),
-			pending: /** @type {Array<{taskId: string, error: string}>} */([])
+			passed: /** @type {string[]} */ ([]),
+			failed: /** @type {string[]} */ ([]),
+			pending: /** @type {Array<{taskId: string, error: string}>} */ ([]),
 		}
 
 		for (const [taskId, testPath] of this.tasks.entries()) {
@@ -92,7 +92,7 @@ export class ProjectManagement {
 					results.failed.push(taskId)
 				}
 			} catch (error) {
-				results.pending.push({ taskId, error: /** @type {Error} */(error).message })
+				results.pending.push({ taskId, error: /** @type {Error} */ (error).message })
 			}
 		}
 
@@ -110,7 +110,7 @@ export class ProjectManagement {
 		return {
 			passed: true,
 			duration: 0,
-			assertions: 0
+			assertions: 0,
 		}
 	}
 
@@ -129,9 +129,9 @@ export class ProjectManagement {
 				total: this.tasks.size,
 				completed: projectState.passed.length,
 				failed: projectState.failed.length,
-				pending: projectState.pending.length
+				pending: projectState.pending.length,
 			},
-			ready: projectState.failed.length === 0
+			ready: projectState.failed.length === 0,
 		}
 	}
 }
@@ -171,7 +171,7 @@ export class ReleaseManager {
 		return {
 			version,
 			validation,
-			published: await this.publish(version, options)
+			published: await this.publish(version, options),
 		}
 	}
 

package/src/cli/index.js

@@ -0,0 +1,9 @@
+/**
+ * Export the UI‑CLI based release CLI.
+ *
+ * @module release/cli
+ */
+
+import createReleaseCLI from '../ui/cli/ReleaseCLi.js'
+
+export default createReleaseCLI

package/src/co/AppCommandOptions.js

@@ -1,4 +1,4 @@
-class AppCommandOptions {
+export default class AppCommandOptions {
 	/** @type {boolean} */
 	webui = false
 	/** @type {boolean} */
@@ -6,16 +6,16 @@ class AppCommandOptions {
 	/** @type {boolean} */
 	quiet = false
 	/** @type {string} */
-	releaseDir = "./releases"
+	releaseDir = './releases'
 	/** @type {boolean} */
 	write = false
 	/** @type {string} */
-	user = "anonymous"
+	user = 'anonymous'
 	/** @type {boolean} */
 	ignoreFailTests = false
 	/** @type {boolean} */
 	full = false
-	
+
 	/**
 	 * @param {Object} input
 	 */
@@ -23,5 +23,3 @@ class AppCommandOptions {
 		Object.assign(this, input)
 	}
 }
-
-export default AppCommandOptions

package/src/commands/CloseCommand.js

@@ -0,0 +1,67 @@
+import { OutputMessage } from '@nan0web/co'
+import Command from './Command.js'
+import process from 'node:process'
+import Scanner from '../Release/Scanner.js'
+
+class CloseBody {
+	static version = { help: 'Release version', defaultValue: '' }
+	/** @type {string} */
+	version = ''
+	constructor({ version = '' } = {}) {
+		this.version = String(version)
+	}
+}
+
+export default class CloseCommand extends Command {
+	static name = 'close'
+	static help = 'Close a release and move tests to src/'
+	static Body = CloseBody
+
+	/** @param {Partial<Command> & { body?: Partial<CloseBody> }} [input={}] */
+	constructor(input = {}) {
+		super(input)
+		this.body = new CloseBody(/** @type {*} */ (input))
+	}
+
+	async *run() {
+		const v = this.body.version || ''
+
+		yield new OutputMessage(`🛜 nan0release close ${v || 'all'}`)
+
+		const scanner = new Scanner(process.cwd())
+		const specs = scanner.findSpecs(v)
+
+		if (specs.length === 0) {
+			yield new OutputMessage(`No pending specs found for version ${v || 'all'}`)
+			return
+		}
+
+		yield new OutputMessage(`Running ${specs.length} pending specs...`)
+
+		const files = specs.map((s) => s.path)
+		await this._run('node', ['--test', ...files], 'Cannot close: Specs failed')
+
+		yield new OutputMessage(`✅ Specs passed. Closing...`)
+
+		let movedCount = 0
+		const { renameSync, mkdirSync } = await import('node:fs')
+		const { join, dirname } = await import('node:path')
+
+		for (const spec of specs) {
+			const relativePath = spec.path.substring(process.cwd().length + 1)
+			const destRelative = relativePath
+				.replace(/^releases\//, 'src/releases/')
+				.replace('.spec.js', '.test.js')
+			const destPath = join(process.cwd(), destRelative)
+
+			mkdirSync(dirname(destPath), { recursive: true })
+			renameSync(spec.path, destPath)
+			movedCount++
+		}
+
+		yield new OutputMessage({
+			content: [`✅ Successfully closed ${movedCount} specs and moved to src/releases/`],
+			type: OutputMessage.TYPES.SUCCESS,
+		})
+	}
+}

package/src/commands/Command.js

@@ -0,0 +1,48 @@
+import DBFS from '@nan0web/db-fs'
+import { OutputMessage } from '@nan0web/co'
+import Logger from '@nan0web/log'
+import { runSpawn } from '@nan0web/test'
+import { UiMessage } from '@nan0web/ui'
+
+/** @typedef {import("@nan0web/test/types/exec/runSpawn").SpawnResult} SpawnResult */
+
+export default class Command extends UiMessage {
+	/** @type {DBFS} */
+	fs
+	/** @type {Logger} */
+	logger
+
+	/**
+	 * @param {Partial<UiMessage> & {  }} [input={}]
+	 */
+	constructor(input = {}) {
+		super(input)
+		const { fs, logger } = UiMessage.parseBody(input, this.Body)
+		this.fs = fs ?? DBFS.from({})
+		this.logger = Logger.from(logger ?? {})
+	}
+	get Body() {
+		return /** @type {typeof Command} */ (this.constructor).Body
+	}
+	/**
+	 * Run the command.
+	 * @param {string} cmd
+	 * @param {string[]} [args=[]]
+	 * @param {string} [fail=""]
+	 * @returns {Promise<SpawnResult>}
+	 * @throws {Error}
+	 */
+	async _run(cmd, args = [], fail = '') {
+		const result = await runSpawn(cmd, args)
+		if (0 !== result.code) {
+			this.logger.error(result.error)
+			throw new Error(fail)
+		}
+		return result
+	}
+
+	/** @returns {AsyncGenerator<OutputMessage>} */
+	async *run() {
+		throw new Error('Must be extended')
+	}
+}