@nan0web/release 1.0.1 → 1.0.2

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

package/src/commands/DepsCommand.js

@@ -0,0 +1,143 @@
+/**
+ * DepsCommand – Message‑based version of the old `DepsCommand`.
+ *
+ * Checks and optionally fixes workspace / link dependencies.
+ *
+ * Body schema:
+ *   fix – boolean – whether to apply fixes (default: false)
+ *
+ * @module release/commands/DepsCommand
+ */
+
+import { Message, OutputMessage } from '@nan0web/co'
+
+import Command from './Command.js'
+
+class DepsBody {
+	/** @type {boolean} */
+	fix = false
+	static fix = {
+		help: 'Apply fixes automatically',
+		defaultValue: false,
+	}
+	/** @type {boolean} */
+	latest = false
+	static latest = {
+		help: 'Update @nan0web packages to the latests available versions',
+		defaultValue: false,
+	}
+	constructor(input = {}) {
+		const { fix = this.fix, latest = this.latest } = Message.parseBody(input, DepsBody)
+		this.fix = Boolean(fix)
+		this.latest = Boolean(latest)
+	}
+}
+
+export default class DepsCommand extends Command {
+	static name = 'deps'
+	static help = 'Dependencies manager'
+	static Body = DepsBody
+	/** @type {DepsBody} */
+	body
+
+	/** @param {Partial<DepsBody>} [input={}] */
+	constructor(input = {}) {
+		super({})
+		this.body = Command.parseBody(input, DepsBody)
+	}
+
+	/**
+	 * @param {DepsCommand} [msg]
+	 * @returns {AsyncGenerator<OutputMessage>}
+	 */
+	async *run(msg = new DepsCommand()) {
+		const pkg = await this.fs.loadDocument('package.json', {})
+		yield new OutputMessage(['Loaded package.json', JSON.stringify(pkg).length + ' bytes'])
+		const deps = {
+			devDependencies: pkg?.devDependencies ?? {},
+			dependencies: pkg?.dependencies ?? {},
+			peerDependencies: pkg?.peerDependencies ?? {},
+		}
+		const fixes = new Map()
+		const fails = new Set()
+
+		const isLocal = (ver) =>
+			['workspace:', 'link:'].some((p) => String(ver).toLowerCase().startsWith(p))
+
+		const changes = new Map()
+
+		for (const [group, map] of Object.entries(deps)) {
+			yield new OutputMessage(`${group} (${Object.keys(map).length} items)`)
+			for (const [dep, ver] of Object.entries(map ?? {})) {
+				if (isLocal(ver) || msg.body.latest) {
+					const result = await this._run(
+						'npm',
+						['info', dep, '--json'],
+						'Cannot retrieve npm package info',
+					)
+					try {
+						const data = JSON.parse(result.text)
+						if (data.version) {
+							fixes.set(dep, data.version)
+							yield new OutputMessage({
+								content: [`  ${dep}: ${ver} → ${data.version}`],
+								type: OutputMessage.TYPES.WARNING,
+							})
+						} else {
+							fails.add(dep)
+							yield new OutputMessage({
+								content: [`  ${dep}: 404 — not found`],
+								type: OutputMessage.TYPES.ERROR,
+							})
+						}
+					} catch (/** @type {any} */ err) {
+						yield new OutputMessage(err)
+					}
+				} else {
+					yield new OutputMessage({
+						content: [`  ${dep}: ${ver}`],
+						type: OutputMessage.TYPES.SUCCESS,
+					})
+				}
+			}
+		}
+
+		if (fails.size) {
+			yield new OutputMessage(
+				new Error(`Some dependencies are not yet published on npm: ${[...fails].join(', ')}`),
+			)
+			return
+		}
+
+		if ((msg.body.fix || msg.body.latest) && fixes.size) {
+			for (const [dep, ver] of fixes) {
+				// naive fix – replace in package.json
+				const args = ['install']
+				if (pkg.devDependencies?.[dep]) {
+					pkg.devDependencies[dep] = ver
+					args.push('--save-dev')
+				}
+				if (pkg.dependencies?.[dep]) pkg.dependencies[dep] = ver
+				args.push(dep + '@latest')
+				if (msg.body.latest) {
+					yield new OutputMessage([`Installing dependency`])
+					await this._run('npm', args)
+				}
+				changes.set(dep, `${dep}: ${ver}`)
+				yield new OutputMessage({
+					content: [`Fixed ${dep} → ${ver}`],
+					type: OutputMessage.TYPES.SUCCESS,
+				})
+			}
+			await this.fs.saveDocument('package.json', pkg)
+			yield new OutputMessage({
+				content: [`Fixes saved (${changes.size} changes)`],
+				type: OutputMessage.TYPES.SUCCESS,
+			})
+			yield new OutputMessage({ content: ['Dependencies fixed'] })
+		} else {
+			yield new OutputMessage(`Run with --fix to apply ${fixes.size} available fixes`)
+			yield new OutputMessage({ content: ['Dependencies check completed'] })
+		}
+	}
+}