@nan0web/release 1.0.0

package/src/commands/PublishCommand.js

@@ -0,0 +1,144 @@
+import process from "node:process"
+import { Command, CommandMessage } from "@nan0web/co"
+import FS from "@nan0web/db-fs"
+import { runSpawn } from '@nan0web/test'
+
+export class PublishCommandOptions {
+	/** @type {string} */
+	tag
+	constructor(input = {}) {
+		const {
+			tag = ""
+		} = input
+		this.tag = String(tag)
+	}
+	/**
+	 * @param {any} input
+	 * @returns {PublishCommandOptions}
+	 */
+	static from(input) {
+		if (input instanceof PublishCommandOptions) return input
+		return new PublishCommandOptions(input)
+	}
+}
+
+/**
+ * @extends {CommandMessage}
+ */
+export class PublishCommandMessage extends CommandMessage {
+	/** @returns {PublishCommandOptions} */
+	get opts() {
+		const opts = super.opts
+		return PublishCommandOptions.from(opts)
+	}
+	set opts(value) {
+		super.opts = value
+	}
+	constructor(input = {}) {
+		super(input)
+	}
+}
+
+/**
+ * @extends {Command}
+ */
+export default class PublishCommand extends Command {
+	static Message = PublishCommandMessage
+
+	constructor(input = {}) {
+		super({
+			name: "publish",
+			help: "Publish package to NPM and create Git tag",
+			...input
+		})
+		this.addArgument("*", String, "", "Category of new version: major, minor, patch, or empty.")
+	}
+
+	/**
+	 * @docs
+	 * # `nan0release publish`
+	 *
+	 * Publishes current package to NPM and creates Git tags.
+	 *
+	 * Steps performed:
+	 * - Verifies no uncommitted changes
+	 * - Pulls latest changes
+	 * - Runs build and test scripts
+	 * - Creates Git tag if not exists
+	 * - Publishes to NPM registry
+	 * - Pushes changes and tags
+	 *
+	 * ```bash
+	 * nan0release publish
+	 * ```
+	 * @param {PublishCommandMessage} msg
+	 */
+	async run(msg) {
+		const fs = new FS()
+		await fs.connect()
+
+		const category = ["major", "minor", "patch"].find(c => msg.args.includes(c))
+		if (category) {
+			await this.#run('npm', ["version", category], "Unable to change version", fs)
+		}
+
+		const pkg = await fs.loadDocument('package.json', {})
+		const tag = `v${pkg.version}`
+
+		await this.#run('git', ["diff", "--quiet"], 'Uncommitted changes found. Commit or stash first.', fs)
+
+		this.logger.info(`🛜 nan0release: publishing @${pkg.name}@${pkg.version}`)
+
+		await this.#run('git', ["pull"], 'Failed to pull latest changes', fs)
+		await this.#run('npm', ["run", "clean"], 'Clean failed', fs)
+		await this.#run('npm', ["run", "build"], 'Build failed', fs)
+		await this.#run('npm', ["test"], 'Tests failed', fs)
+
+		const tagsResult = await this.#run('git', ["tag"], "Failed to get tags", fs)
+		const tags = tagsResult.text.split('\n').filter(Boolean)
+
+		if (!tags.includes(tag)) {
+			await this.#run('git', ['tag', '-a', tag, '-m', `Release ${pkg.version}`], 'Tag creation failed', fs)
+		} else {
+			this.logger.warn(`Tag ${tag} already exists`)
+		}
+
+		await this.#run('npm', ['publish', '--access', 'public'], 'Publish to npm failed', fs)
+
+		await this.#run('git', ['push', 'origin', 'main', '--no-verify'], 'Git push failed', fs)
+		await this.#run('git', ['push', 'origin', '--tags', '--no-verify'], 'Tag push failed', fs)
+
+		this.logger.success(`@${pkg.name}@${pkg.version} published. Zero becomes script of a life 🌱`)
+	}
+
+	/**
+	 * @param {string} cmd
+	 * @param {string[]} args
+	 * @param {string} errorMsg
+	 * @param {FS} fs
+	 * @param {number[]} [okCodes=[0]]
+	 */
+	async #run(cmd, args, errorMsg, fs, okCodes = [0]) {
+		let content = ""
+		const onData = (chunk) => {
+			content += String(chunk)
+			const rows = content.split("\n").filter(Boolean)
+			const recent = rows.slice(-1)
+			if (recent.length) {
+				this.logger.cursorUp(1, true)
+				this.logger.info(recent[0])
+			}
+		}
+
+		let cwd = fs.absolute()
+		if ("/" === cwd && "." === fs.cwd) cwd = fs.cwd
+		const response = await runSpawn(cmd, args, { onData, cwd })
+
+		if (!okCodes.includes(response.code)) {
+			this.logger.error(errorMsg)
+			process.exit(1)
+		}
+
+		return response
+	}
+}

package/src/commands/SealCommand.js

@@ -0,0 +1,51 @@
+import SubCommand from "./SubCommand.js"
+import { mkdir, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import Release from "../../src/Release.js"
+
+/**
+ * SealCommand – finalises a release by writing a `retro.md` file
+ * and making the release directory read‑only.  This is a *light* implementation
+ * that merely creates a placeholder retro file; a real implementation would
+ * also set file system permissions and maybe create a Git tag.
+ *
+ * Usage:
+ *   release seal [--message <text>]
+ *
+ * Options:
+ *   --message – optional retro‑reflection text
+ */
+export default class SealCommand extends SubCommand {
+	constructor(options = {}) {
+		super(options)
+		this.addOption("message", String, "", "Retro‑reflection text")
+	}
+
+	/**
+	 * Seal the current release.
+	 *
+	 * @param {Object} ctx – command context
+	 */
+	async run(ctx) {
+		if (!this.db) {
+			this.logger.error("No DB – cannot seal release")
+			return
+		}
+
+		const retroPath = join(this.db.cwd, "retro.md")
+		const content = `# Retro – ${new Date().toISOString().split("T")[0]}
+
+${ctx.opts.message || "*No retro‑reflection provided.*"}\n`
+
+		await writeFile(retroPath, content, "utf8")
+		this.logger.success(`retro.md written to ${retroPath}`)
+
+		// make the folder read‑only (best‑effort – ignore errors on non‑POSIX FS)
+		try {
+			await mkdir(this.db.cwd, { mode: 0o444 })
+			this.logger.info("Release directory set to read‑only")
+		} catch (_) {
+			// not critical – just a hint
+		}
+	}
+}

package/src/commands/ServeCommand.js

@@ -0,0 +1,53 @@
+import SubCommand from "./SubCommand.js"
+import { createServer } from "node:http"
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+/**
+ * ServeCommand – runs a tiny static file server that serves all files
+ * inside the current release folder.  It is useful for quick local
+ * inspection of assets, markdown, and generated test files.
+ *
+ * Usage:
+ *   release serve [--port <number>]
+ */
+export default class ServeCommand extends SubCommand {
+	constructor(options = {}) {
+		super(options)
+		this.addOption("port", Number, 8080, "Port for static server")
+	}
+
+	/**
+	 * Start the static server.
+	 *
+	 * @param {Object} ctx – command context
+	 */
+	async run(ctx) {
+		if (!this.db) {
+			this.logger.error("No DB – cannot serve files")
+			return
+		}
+
+		const root = this.db.cwd
+		const port = ctx.opts.port
+
+		const server = createServer(async (req, res) => {
+			const safePath = req.url?.split("?")[0] || "/"
+			const filePath = join(root, safePath)
+
+			try {
+				const data = await readFile(filePath)
+				res.writeHead(200)
+				res.end(data)
+			} catch (_) {
+				res.writeHead(404)
+				res.end("Not found")
+			}
+		})
+
+		server.listen(port, () => {
+			this.logger.success(`Static server listening on http://localhost:${port}`)
+			this.logger.info(`Serving ${root}`)
+		})
+	}
+}

package/src/commands/ShowCommand.js

@@ -0,0 +1,58 @@
+import SubCommand from "./SubCommand.js"
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+/**
+ * ShowCommand – prints basic information about the current release
+ * (version, creation date, and a short excerpt of the markdown notes).
+ *
+ * Usage:
+ *   release show
+ *
+ * Options:
+ *   --full – dump the whole release.md file
+ */
+export default class ShowCommand extends SubCommand {
+	constructor(options = {}) {
+		super(options)
+		this.addOption("full", Boolean, false, "Show complete release.md")
+	}
+
+	/**
+	 * Render the release information.
+	 *
+	 * @param {Object} ctx – command context
+	 */
+	async run(ctx) {
+		if (!this.db) {
+			this.logger.error("No DB – cannot locate current release")
+			return
+		}
+
+		// `cwd` points to the current release directory (see CLI)
+		const releaseJsPath = join(this.db.cwd, "release.js")
+		const releaseMdPath = join(this.db.cwd, "release.md")
+
+		try {
+			const { default: release } = await import(releaseJsPath)
+			this.logger.info(`Version      : ${release.version}`)
+			this.logger.info(`Created at   : ${release.createdAt.toISOString()}`)
+			this.logger.info(`Path         : ${this.db.cwd}`)
+		} catch (/** @type {any} */ e) {
+			this.logger.warn(`Unable to import release.js – ${e.message}`)
+		}
+
+		try {
+			const md = await readFile(releaseMdPath, "utf8")
+			if (ctx.opts.full) {
+				this.logger.info("\n=== release.md ===\n")
+				this.logger.info(md)
+			} else {
+				const firstLine = md.split("\n")[0]
+				this.logger.info(`Release note : ${firstLine}`)
+			}
+		} catch (/** @type {any} */ e) {
+			this.logger.warn(`release.md not found – ${e.message}`)
+		}
+	}
+}

package/src/commands/SubCommand.js

@@ -0,0 +1,21 @@
+import { Command } from '@nan0web/co'
+import ReleaseDB from '../db/ReleaseDB.js'
+import Logger from '@nan0web/log'
+
+class SubCommand extends Command {
+	/** @type {Logger} */
+	logger
+	/** @type {ReleaseDB?} */
+	db
+	constructor(options = {}) {
+		const {
+			logger = new Logger(),
+			db,
+		} = options
+		super(options)
+		this.logger = Logger.from(logger)
+		this.db = db ? ReleaseDB.from(db) : null
+	}
+}
+
+export default SubCommand

package/src/commands/ValidateCommand.js

@@ -0,0 +1,66 @@
+import SubCommand from "./SubCommand.js"
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+import Release from "../../src/Release.js"
+
+/**
+ * ValidateCommand – runs the {@link Release.validate} method for the
+ * currently checked‑out release and prints a short summary.
+ *
+ * Usage:
+ *   release validate
+ *
+ * Options:
+ *   --ignore-fail – do not treat failed tasks as a validation error
+ */
+export default class ValidateCommand extends SubCommand {
+	constructor(options = {}) {
+		super(options)
+		this.addOption("ignoreFailTests", Boolean, false, "Ignore failed tests")
+	}
+
+	/**
+	 * Execute validation.
+	 *
+	 * @param {Object} ctx – command context
+	 */
+	async run(ctx) {
+		if (!this.db) {
+			this.logger.error("No DB – cannot locate current release")
+			return
+		}
+
+		const releaseJsPath = join(this.db.cwd, "release.js")
+		const releaseMdPath = join(this.db.cwd, "release.md")
+
+		let releaseInst
+		try {
+			const { default: rel } = await import(releaseJsPath)
+			releaseInst = rel
+		} catch (/** @type {any} */ e) {
+			this.logger.error(`Failed to import release.js – ${e.message}`)
+			return
+		}
+
+		// Attach a mock document – the real implementation would parse markdown
+		try {
+			const md = await readFile(releaseMdPath, "utf8")
+			// Very naïve parsing – just store the raw markdown
+			releaseInst.document = md
+		} catch (_) {
+			// ignore – document is optional for validation
+		}
+
+		const result = await releaseInst.validate()
+		const { passed, failed, pending } = result
+
+		if (passed.length) this.logger.success(`✅ Passed: ${passed.join(", ")}`)
+		if (failed.length) this.logger.error(`❌ Failed: ${failed.map(f => f.taskId).join(", ")}`)
+		if (pending.length) this.logger.warn(`● Pending: ${pending.map(p => p.taskId).join(", ")}`)
+
+		if (!ctx.opts.ignoreFailTests && failed.length) {
+			this.logger.error(`Validation failed – ${failed.length} tasks did not pass`)
+			process.exit(1)
+		}
+	}
+}

package/src/db/ReleaseDB.js

@@ -0,0 +1,54 @@
+import DBFS from "@nan0web/db-fs"
+
+/**
+ * ReleaseDB – thin wrapper around DBFS that adds a convenient `releases`
+ * getter returning all release directories discovered under the root.
+ *
+ * The underlying DBFS stores a `Map` called `data` where each key is a
+ * relative file path (e.g. "1/0/v1.0.0/release.js").
+ */
+class ReleaseDB extends DBFS {
+	/**
+	 * @param {string} uri
+	 * @returns {ReleaseDB}
+	 */
+	extract(uri) {
+		return new ReleaseDB(super.extract(uri))
+	}
+	/**
+	 * @param {string} version
+	 * @returns {ReleaseDB}
+	 */
+	extractVersion(version) {
+		const found = version.match(/^v(\d+)\.(\d+)\.(\d+)$/)
+		if (!found) {
+			throw new Error("Incorrect version")
+		}
+		const arr = version.slice(1).split(".")
+		const path = [arr[0], arr[1], version, ""].join("/")
+		return ReleaseDB.from(this.extract(path))
+	}
+	/**
+	 * @returns {Array<string>} List of discovered release root paths
+	 */
+	get releases() {
+		const paths = new Set()
+		for (const key of this.data.keys()) {
+			// Expected structure: major/minor/vX.Y.Z/…
+			const parts = key.split("/")
+			if (parts.length > 2 && /^\d+$/.test(parts[0]) && /^\d+$/.test(parts[1])) {
+				paths.add(`${parts[0]}/${parts[1]}/${parts[2]}`)
+			}
+		}
+		return Array.from(paths)
+	}
+	/**
+	 * @param {object} input
+	 * @returns {ReleaseDB}
+	 */
+	static from(input) {
+		if (input instanceof ReleaseDB) return input
+		return new ReleaseDB(input)
+	}
+}
+export default ReleaseDB