@nan0web/release 1.0.1 → 1.0.2

package/src/Release/MarkdownToTest.test.js

@@ -1,60 +0,0 @@
-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/ReleaseCLI.js

@@ -1,122 +0,0 @@
-#!/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/architecture/ProjectManagementAsCode.test.js

@@ -1,128 +0,0 @@
-import { describe, it } from 'node:test'
-import { strict as assert } from 'node:assert'
-import {
-	ProjectManagement,
-	ReleaseManager,
-	TaskTestSuite,
-	ChangelogTaskManager
-} from './ProjectManagementAsCode.js'
-
-describe('ProjectManagementAsCode Architecture', () => {
-	describe('ProjectManagement', () => {
-		it('should initialize with default configuration', () => {
-			const pm = new ProjectManagement()
-			assert.equal(pm.projectPath, '.')
-			assert.equal(pm.autoTrack, false)
-			assert.ok(pm.tasks instanceof Map)
-		})
-
-		it('should register tasks with their test files', () => {
-			const pm = new ProjectManagement()
-			pm.registerTask('task-1', './tests/task1.test.js')
-			pm.registerTask('task-2', './tests/task2.test.js')
-
-			assert.equal(pm.tasks.size, 2)
-			assert.equal(pm.tasks.get('task-1'), './tests/task1.test.js')
-			assert.equal(pm.tasks.get('task-2'), './tests/task2.test.js')
-		})
-
-		it('should validate project state by running task tests', async () => {
-			const pm = new ProjectManagement()
-			pm.registerTask('task-1', './tests/task1.test.js')
-			pm.registerTask('task-2', './tests/task2.test.js')
-
-			const results = await pm.validateProjectState()
-			assert.ok(results.passed.length >= 0)
-			assert.ok(results.failed.length >= 0)
-			assert.ok(results.pending.length >= 0)
-		})
-	})
-
-	describe('ReleaseManager', () => {
-		it('should initialize with project manager', () => {
-			const pm = new ProjectManagement()
-			const rm = new ReleaseManager(pm)
-
-			assert.equal(rm.projectManager, pm)
-		})
-
-		it.skip('should validate release with version calculation', async () => {
-			const pm = new ProjectManagement()
-			const rm = new ReleaseManager(pm)
-
-			const validation = await rm.validateRelease('1.0.0')
-			assert.equal(validation.version, '1.0.0')
-			assert.ok(validation.timestamp)
-			assert.ok(validation.tasks.total >= 0)
-		})
-
-		it('should execute release process with validation', async () => {
-			const pm = new ProjectManagement()
-			const rm = new ReleaseManager(pm)
-
-			const result = await rm.executeRelease('patch')
-			assert.ok(result.version)
-			assert.ok(result.validation)
-			assert.equal(typeof result.published, 'boolean')
-		})
-
-		it('should block release when tests fail and ignore option is not set', async () => {
-			const pm = new ProjectManagement()
-			const rm = new ReleaseManager(pm)
-
-			// Mock validation to simulate failed tasks
-			rm.projectManager.validateProjectState = async () => ({
-				passed: [],
-				failed: ['task-1'],
-				pending: []
-			})
-
-			try {
-				await rm.executeRelease('patch')
-				assert.fail('Should have thrown an error')
-			} catch (error) {
-				assert.ok(error.message.includes('Release blocked'))
-			}
-		})
-	})
-
-	describe('TaskTestSuite', () => {
-		it.skip('should extend TestSuite with task metadata', () => {
-			const testFunction = () => { }
-			const taskSuite = new TaskTestSuite('task-1', 'Test task description', testFunction)
-
-			assert.equal(taskSuite.taskId, 'task-1')
-			assert.equal(taskSuite.description, 'Test task description')
-			assert.equal(taskSuite.testFunction, testFunction)
-		})
-	})
-
-	describe('ChangelogTaskManager', () => {
-		it('should parse changelog content to extract tasks', () => {
-			const ctm = new ChangelogTaskManager()
-			const changelogContent = `
-# Changelog
-
-## [1.0.0] - 2024-01-01
-### Added
-- Initial release features
-- Core functionality implementation
-`
-
-			const tasks = ctm.parseChangelog(changelogContent)
-			assert.ok(Array.isArray(tasks))
-		})
-
-		it('should generate task tests from changelog entries', async () => {
-			const ctm = new ChangelogTaskManager()
-			const tasks = [
-				{ id: 'task-1', description: 'Implement feature A' },
-				{ id: 'task-2', description: 'Fix bug B' }
-			]
-
-			// This should not throw an error
-			await ctm.generateTaskTests(tasks)
-			assert.ok(true)
-		})
-	})
-})

package/src/co/AppCommandMessage.js

@@ -1,22 +0,0 @@
-import { CommandMessage } from "@nan0web/co"
-import AppCommandOptions from "./AppCommandOptions.js"
-
-export default class AppCommandMessage extends CommandMessage {
-	/** @returns {AppCommandOptions} */
-	get opts() {
-		return /** @type {AppCommandOptions} */ (super.opts)
-	}
-
-	set opts(value) {
-		super.opts = value
-	}
-
-	/**
-	 * @param {*} input
-	 * @returns {AppCommandMessage}
-	 */
-	static from(input) {
-		if (input instanceof AppCommandMessage) return input
-		return new AppCommandMessage(input)
-	}
-}

package/src/commands/ChatCommand.js

@@ -1,56 +0,0 @@
-import SubCommand from "./SubCommand.js"
-import { appendFile, readFile } from "node:fs/promises"
-import { join } from "node:path"
-import AppCommandMessage from "../co/AppCommandMessage.js"
-
-/**
- * ChatCommand – writes a message to the release‑wide chat (chat/…/timestamp.username.md)
- *
- * Usage:
- *   release chat write "your message"
- *
- * Options:
- *   --user <string> – username to embed in the filename (defaults to "anonymous")
- */
-class ChatCommand extends SubCommand {
-	constructor(options = {}) {
-		super(options)
-		this.addOption("user", String, "anonymous", "Chat username")
-		this.addOption("write", Boolean, false, "Write a new chat line")
-	}
-
-	/**
-	 * Run the chat command.
-	 *
-	 * @param {AppCommandMessage} ctx – command context (contains args and opts)
-	 */
-	async run(ctx) {
-		if (!ctx.opts.write) {
-			this.logger.error("No action specified – use --write to add a message")
-			return
-		}
-		if (!this.db) {
-			this.logger.error("No DB – cannot locate chat folder")
-			return
-		}
-
-		const message = ctx.args.join(" ")
-		if (!message) {
-			this.logger.error("Empty message – nothing to write")
-			return
-		}
-
-		const now = Date.now()
-		const username = /** @type {string} */(ctx.opts.user)
-		const chatPath = join(this.db.cwd, "chat", "2025", "08", `${now}.${username}.md`)
-
-		// ensure directory exists
-		const dir = chatPath.split("/").slice(0, -1).join("/")
-		await import("node:fs/promises").then(m => m.mkdir(dir, { recursive: true }))
-
-		await appendFile(chatPath, message + "\n", "utf8")
-		this.logger.success(`Message written to ${chatPath}`)
-	}
-}
-
-export default ChatCommand

package/src/commands/HostCommand.js

@@ -1,63 +0,0 @@
-import SubCommand from "./SubCommand.js"
-import { createServer } from "node:http"
-import { readFile } from "node:fs/promises"
-import { join } from "node:path"
-
-/**
- * HostCommand – starts a minimal HTTP server that serves the current
- * release markdown and a tiny JSON status endpoint.
- *
- * Usage:
- *   release host [--port <number>] [--webui]
- */
-export default class HostCommand extends SubCommand {
-	constructor(options = {}) {
-		super(options)
-		this.addOption("port", Number, 3000, "Port for the HTTP server")
-		this.addOption("webui", Boolean, false, "Serve a simple web UI")
-	}
-
-	/**
-	 * Run the host server.
-	 *
-	 * @param {Object} ctx – command context
-	 */
-	async run(ctx) {
-		const port = ctx.opts.port
-		const releasePath = this.db?.cwd
-		if (!releasePath) {
-			this.logger.error("No release directory (db.cwd) – cannot host")
-			return
-		}
-
-		const mdPath = join(releasePath, "release.md")
-
-		const server = createServer(async (req, res) => {
-			if (req.url === "/") {
-				// simple UI – just render markdown as preformatted text
-				try {
-					const md = await readFile(mdPath, "utf8")
-					const body = ctx.opts.webui
-						? `<html><body><pre>${md}</pre></body></html>`
-						: md
-					res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" })
-					res.end(body)
-				} catch (e) {
-					res.writeHead(404)
-					res.end("release.md not found")
-				}
-			} else if (req.url === "/status") {
-				res.writeHead(200, { "Content-Type": "application/json" })
-				res.end(JSON.stringify({ version: ctx.opts.version || "unknown" }))
-			} else {
-				res.writeHead(404)
-				res.end("Not found")
-			}
-		})
-
-		server.listen(port, () => {
-			this.logger.success(`Release hosted at http://localhost:${port}`)
-			if (ctx.opts.webui) this.logger.info("Web UI enabled")
-		})
-	}
-}

package/src/commands/ListCommand.js

@@ -1,56 +0,0 @@
-import SubCommand from "./SubCommand.js"
-import { join } from "node:path"
-import { createReadStream } from "node:fs"
-
-/**
- * ListCommand – prints a concise list of releases found in the current
- * working directory.  It works against the {@link ReleaseDB} instance
- * passed through the `db` option of the parent CLI.
- *
- * Usage:
- *   release list
- *
- * Options:
- *   --json – output JSON instead of a human‑readable list
- */
-export default class ListCommand extends SubCommand {
-	constructor(options = {}) {
-		super(options)
-		this.addOption("json", Boolean, false, "Output as JSON")
-	}
-
-	/**
-	 * Execute the command.
-	 *
-	 * @param {Object} ctx – command context (contains parsed args)
-	 * @returns {Promise<void>}
-	 */
-	async run(ctx) {
-		if (!this.db) {
-			this.logger.warn("No database attached – nothing to list")
-			return
-		}
-
-		const releases = []
-		for await (const entry of this.db.findStream("")) {
-			// Only keep top‑level release directories (e.g. 1/0/v1.0.0)
-			const parts = entry.file.path.split("/")
-			if (parts.length === 3 && /^\d+$/.test(parts[0]) && /^\d+$/.test(parts[1])) {
-				releases.push(entry.file.path)
-			}
-		}
-
-		if (ctx.opts.json) {
-			this.logger.info(JSON.stringify(releases, null, "\t"))
-		} else {
-			if (releases.length === 0) {
-				this.logger.info("No releases found")
-			} else {
-				this.logger.info("Releases:")
-				for (const r of releases) {
-					this.logger.info(` • ${r}`)
-				}
-			}
-		}
-	}
-}

package/src/commands/SealCommand.js

@@ -1,51 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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