@nan0web/release 1.0.1 → 1.0.3

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

package/src/commands/InitCommand.js

@@ -1,65 +1,57 @@
-import SubCommand from "./SubCommand.js"
-import AppCommandMessage from "../co/AppCommandMessage.js"
-import { CommandError } from "@nan0web/co"
+import { OutputMessage } from '@nan0web/co'
+import Command from './Command.js'
+import process from 'node:process'
 
-/**
- * InitCommand – scaffolds a new release directory with the minimal set of
- * files required for a functional release (release.js, release.md and a
- * placeholder task folder).  The command is deliberately tiny – it only
- * creates the filesystem layout and writes a tiny starter release object.
- *
- * Usage:
- *   release init v1.0.0
- */
-class InitCommand extends SubCommand {
-	constructor(options = {}) {
-		super(options)
-		this.addArgument("*", String, "", "Version for the new release")
+class InitBody {
+	static version = { help: 'Release version', defaultValue: '' }
+	/** @type {string} */
+	version = ''
+	constructor({ version = '' } = {}) {
+		this.version = String(version)
 	}
+}
 
-	/**
-	 * Run the init process.
-	 *
-	 * @param {AppCommandMessage} msg – command context (contains parsed options)
-	 */
-	async run(msg) {
-		if (!this.db) {
-			throw new CommandError("Database (working directory) not set")
-		}
-		const version = msg.args[0]
-		if (!version) {
-			throw new CommandError("Version not defined", msg)
-		}
-		const db = this.db.extractVersion(version)
+export default class InitCommand extends Command {
+	static name = 'init'
+	static help = 'Initialize a new release structure'
+	static Body = InitBody
 
-		const files = [
-			["release.js", [
-				'import Release from "../../../src/Release.js"',
-				'export default new Release({',
-				`	version: "${version}",`,
-				'	createdAt: new Date(),',
-				'	tasks: new Map()',
-				'})',
-			].join("\n")],
-			["release.md", [
-				`# ${version} - ${new Date().toISOString().split("T")[0]}`,
-				'## Overview',
-				'Initial release scaffold generated by `nan0release init`.',
-			].join("\n\n")]
-		]
+	/** @param {Partial<Command> & { body?: Partial<InitBody> }} [input={}] */
+	constructor(input = {}) {
+		super(input)
+		this.body = new InitBody(/** @type {*} */ (input))
+	}
 
-		for (const [file, content] of files) {
-			const jsExists = await db.loadDocument(file)
-			if (jsExists) {
-				this.logger.warn(file, "exists already")
-			} else {
-				await db.saveDocument(file, content)
-				this.logger.success(file, "created")
-			}
+	async *run() {
+		let v = this.body.version
+		if (!v) {
+			throw new Error('Version is required (e.g. --version=1.0.0 or --version=v1.0.0)')
 		}
+		if (!v.startsWith('v')) v = 'v' + v
+
+		const parts = v.replace('v', '').split('.')
+		const major = parts[0] || '0'
+		const minor = parts[1] || '0'
 
-		this.logger.success(`Release ${version} created`)
+		const { mkdirSync, writeFileSync } = await import('node:fs')
+		const { join } = await import('node:path')
+
+		const dir = join(process.cwd(), 'releases', major, minor, v)
+		mkdirSync(dir, { recursive: true })
+
+		const taskPath = join(dir, 'task.md')
+		writeFileSync(taskPath, `# Release ${v}\n\n- [ ] Task 1`, 'utf8')
+
+		const specPath = join(dir, 'test.spec.js')
+		writeFileSync(
+			specPath,
+			`import test from 'node:test'\nimport assert from 'node:assert'\n\ntest('Sample spec', () => {\n\tassert.ok(true)\n})\n`,
+			'utf8',
+		)
+
+		yield new OutputMessage({
+			content: [`✅ Initialized release ${v} in ${dir}`],
+			type: OutputMessage.TYPES.SUCCESS,
+		})
 	}
 }
-
-export default InitCommand

package/src/commands/PublishCommand.js

@@ -1,144 +1,105 @@
-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}
+ * PublishCommand – Message‑based version of the old `PublishCommand`.
+ *
+ * Publishes the current package to NPM and creates a Git tag.
+ *
+ * Body schema:
+ *   major | minor | patch – optional version bump flag.
+ *
+ * @module release/commands/PublishCommand
  */
-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)
+
+import { Message, OutputMessage } from '@nan0web/co'
+
+import Command from './Command.js'
+
+class PublishBody {
+	static major = { help: 'Bump major version', defaultValue: false }
+	static minor = { help: 'Bump minor version', defaultValue: false }
+	static patch = { help: 'Bump patch version', defaultValue: false }
+
+	/** @type {boolean} */
+	major = false
+	/** @type {boolean} */
+	minor = false
+	/** @type {boolean} */
+	patch = false
+
+	constructor({ major = false, minor = false, patch = false } = {}) {
+		this.major = Boolean(major)
+		this.minor = Boolean(minor)
+		this.patch = Boolean(patch)
 	}
 }
 
-/**
- * @extends {Command}
- */
 export default class PublishCommand extends Command {
-	static Message = PublishCommandMessage
+	static name = 'publish'
+	static help = 'Publish npm packages'
+	static Body = PublishBody
+
+	/** @type {PublishBody} */
+	body
 
+	/** @param {Partial<Command> & { body?: Partial<PublishBody> }} [input={}] */
 	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.")
+		super(input)
+		const { body = new PublishBody() } = Message.parseBody(input, PublishBody)
+		this.body = new PublishBody(body)
 	}
 
-	/**
-	 * @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)
+	/** @returns {AsyncGenerator<OutputMessage>} */
+	async *run() {
+		const bump = this.body.major
+			? 'major'
+			: this.body.minor
+				? 'minor'
+				: this.body.patch
+					? 'patch'
+					: null
+		if (bump) {
+			await this._run('npm', ['version', bump], 'Failed to bump version')
 		}
-
-		const pkg = await fs.loadDocument('package.json', {})
+		const pkg = await this.fs.loadDocument('package.json', {})
 		const tag = `v${pkg.version}`
 
-		await this.#run('git', ["diff", "--quiet"], 'Uncommitted changes found. Commit or stash first.', fs)
+		yield new OutputMessage(`🛜 nan0release: publishing @${pkg.name}@${pkg.version}`)
+
+		await this._run('git', ['diff', '--quiet'], 'Uncommitted changes found')
 
-		this.logger.info(`🛜 nan0release: publishing @${pkg.name}@${pkg.version}`)
+		await this._run('git', ['pull'], 'Failed to pull latest changes')
+		await this._run('npm', ['run', 'clean'], 'Clean failed')
+		await this._run('npm', ['run', 'build'], 'Build failed')
+		await this._run('npm', ['test'], 'Tests failed')
 
-		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)
+		return
 
-		const tagsResult = await this.#run('git', ["tag"], "Failed to get tags", fs)
+		const tagsResult = await this._run('git', ['tag'], 'Failed to get tags')
 		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)
+			await this._run(
+				'git',
+				['tag', '-a', tag, '-m', `Release ${pkg.version}`],
+				'Tag creation failed',
+			)
+			yield new OutputMessage({
+				content: [`Tag ${tag} created`],
+				type: OutputMessage.TYPES.SUCCESS,
+			})
 		} else {
-			this.logger.warn(`Tag ${tag} already exists`)
+			yield new OutputMessage({
+				content: [`Tag ${tag} already exists`],
+				type: OutputMessage.TYPES.WARNING,
+			})
 		}
 
-		await this.#run('npm', ['publish', '--access', 'public'], 'Publish to npm failed', fs)
+		await this._run('npm', ['publish', '--access', 'public'], 'Publish to npm failed')
+		await this._run('git', ['push', 'origin', 'main', '--no-verify'], 'Git push failed')
+		await this._run('git', ['push', 'origin', '--tags', '--no-verify'], 'Tag push failed')
 
-		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
+		yield new OutputMessage({
+			content: [`${pkg.name}@${pkg.version} published.`],
+			type: OutputMessage.TYPES.SUCCESS,
+		})
 	}
 }

package/src/commands/SpecCommand.js

@@ -0,0 +1,41 @@
+import { OutputMessage } from '@nan0web/co'
+import Command from './Command.js'
+import process from 'node:process'
+import Scanner from '../Release/Scanner.js'
+
+class SpecBody {
+	static version = { help: 'Release version filter', defaultValue: '' }
+	/** @type {string} */
+	version = ''
+	constructor({ version = '' } = {}) {
+		this.version = String(version)
+	}
+}
+
+export default class SpecCommand extends Command {
+	static name = 'spec'
+	static help = 'Run spec testing for the active release'
+	static Body = SpecBody
+
+	/** @param {Partial<Command> & { body?: Partial<SpecBody> }} [input={}] */
+	constructor(input = {}) {
+		super(input)
+		this.body = new SpecBody(/** @type {*} */ (input))
+	}
+
+	async *run() {
+		yield new OutputMessage(`🛜 nan0release spec ${this.body.version || 'all'}`)
+		const scanner = new Scanner(process.cwd())
+		const specs = scanner.findSpecs(this.body.version)
+		if (specs.length === 0) {
+			yield new OutputMessage(`No specs found.`)
+			return
+		}
+		const files = specs.map((s) => s.path)
+		await this._run('node', ['--test', ...files], 'Specs failed')
+		yield new OutputMessage({
+			content: [`✅ Specs passed`],
+			type: OutputMessage.TYPES.SUCCESS,
+		})
+	}
+}

package/src/commands/StatusCommand.js

@@ -0,0 +1,26 @@
+import { OutputMessage } from '@nan0web/co'
+import Command from './Command.js'
+import process from 'node:process'
+import Scanner from '../Release/Scanner.js'
+
+export default class StatusCommand extends Command {
+	static name = 'status'
+	static help = 'Show release status'
+
+	constructor(input = {}) {
+		super(input)
+		this.body = {}
+	}
+
+	async *run() {
+		const scanner = new Scanner(process.cwd())
+		const statuses = scanner.status()
+
+		yield new OutputMessage(`🛜 nan0release status`)
+		for (const st of statuses) {
+			yield new OutputMessage(
+				`${st.version.padEnd(10)} | ${st.state.padEnd(6)} | Specs: ${st.specs.length}, Tests: ${st.tests.length}`,
+			)
+		}
+	}
+}

package/src/db/ReleaseDB.js

@@ -1,4 +1,4 @@
-import DBFS from "@nan0web/db-fs"
+import DBFS from '@nan0web/db-fs'
 
 /**
  * ReleaseDB – thin wrapper around DBFS that adds a convenient `releases`
@@ -22,10 +22,10 @@ class ReleaseDB extends DBFS {
 	extractVersion(version) {
 		const found = version.match(/^v(\d+)\.(\d+)\.(\d+)$/)
 		if (!found) {
-			throw new Error("Incorrect version")
+			throw new Error('Incorrect version')
 		}
-		const arr = version.slice(1).split(".")
-		const path = [arr[0], arr[1], version, ""].join("/")
+		const arr = version.slice(1).split('.')
+		const path = [arr[0], arr[1], version, ''].join('/')
 		return ReleaseDB.from(this.extract(path))
 	}
 	/**
@@ -35,7 +35,7 @@ class ReleaseDB extends DBFS {
 		const paths = new Set()
 		for (const key of this.data.keys()) {
 			// Expected structure: major/minor/vX.Y.Z/…
-			const parts = key.split("/")
+			const parts = key.split('/')
 			if (parts.length > 2 && /^\d+$/.test(parts[0]) && /^\d+$/.test(parts[1])) {
 				paths.add(`${parts[0]}/${parts[1]}/${parts[2]}`)
 			}

package/src/index.js

@@ -0,0 +1,18 @@
+import Release from './Release.js'
+import ReleaseDocument from './Release/Document.js'
+import Person from './Release/Person.js'
+import Scanner from './Release/Scanner.js'
+import MarkdownToTest from './Release/MarkdownToTest.js'
+import { ProjectManagement, ReleaseManager, TaskTestSuite, ChangelogTaskManager } from './architecture/ProjectManagementAsCode.js'
+
+export {
+	Release,
+	ReleaseDocument,
+	Person,
+	Scanner,
+	MarkdownToTest,
+	ProjectManagement,
+	ReleaseManager,
+	TaskTestSuite,
+	ChangelogTaskManager
+}

package/src/ui/cli/ReleaseCLi.js

@@ -0,0 +1,52 @@
+/**
+ * ReleaseCLI – UI‑CLI driven entry point that registers the
+ * Message‑based release commands.
+ *
+ * Usage (from terminal):
+ *
+ *   npx nan0release <subcommand> [options] [args]
+ *
+ * Subcommands:
+ *   init, deps, publish, seal, host, serve, list, validate, chat
+ *
+ * Each subcommand is a Message class exporting a `run` async generator
+ * that yields {@link OutputMessage}s.
+ *
+ * @module release/cli/ReleaseCLI
+ */
+import process from 'node:process'
+
+import { CLI } from '@nan0web/ui-cli'
+import Logger from '@nan0web/log'
+import DBFS from '@nan0web/db-fs'
+import DepsCommand from '../../commands/DepsCommand.js'
+import PublishCommand from '../../commands/PublishCommand.js'
+import InitCommand from '../../commands/InitCommand.js'
+import SpecCommand from '../../commands/SpecCommand.js'
+import CloseCommand from '../../commands/CloseCommand.js'
+import StatusCommand from '../../commands/StatusCommand.js'
+
+class ReleaseCLi extends CLI {
+	/** @type {DBFS} */
+	fs
+	constructor(input) {
+		super(input)
+		const { fs } = input
+		this.fs = fs ?? DBFS.from({})
+	}
+}
+
+export default function createReleaseCLI(
+	argv = process.argv.slice(2),
+	logger = new Logger(),
+	fs = {},
+) {
+	const cli = new ReleaseCLi({
+		argv,
+		commands: {}, // no map‑based commands
+		Messages: [InitCommand, DepsCommand, PublishCommand, SpecCommand, CloseCommand, StatusCommand],
+		logger,
+		fs: DBFS.from(fs),
+	})
+	return cli
+}

package/types/Release/Document.d.ts

@@ -27,5 +27,5 @@ declare class ReleaseDocument extends Markdown {
     /** @type {Date | undefined} */
     date: Date | undefined;
 }
-import Markdown from "@nan0web/markdown";
-import Person from "./Person.js";
+import Markdown from '@nan0web/markdown';
+import Person from './Person.js';

package/types/Release/Person.d.ts

@@ -12,6 +12,6 @@ export default class Person {
     /** @type {HumanContact[]} */
     contacts: HumanContact[];
 }
-import { HumanName } from "@nan0web/verse";
-import { HumanGender } from "@nan0web/verse";
-import { HumanContact } from "@nan0web/verse";
+import { HumanName } from '@nan0web/verse';
+import { HumanGender } from '@nan0web/verse';
+import { HumanContact } from '@nan0web/verse';