@nan0web/release 3.1.0 → 3.2.0

package/bin/nan0release.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
 import { bootstrapApp } from '@nan0web/ui-cli'
-import { App } from '../src/domain/App.js'
+import { ReleaseApp } from '../src/domain/App.js'
 
-bootstrapApp(App)
+bootstrapApp(ReleaseApp)

package/bin/release.test.js

@@ -0,0 +1,81 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import FS from '@nan0web/db-fs'
+import { existsSync, writeFileSync, unlinkSync, mkdirSync, readFileSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import main from './release.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const tempDir = resolve(__dirname, 'temp')
+const tempPackageJson = resolve(tempDir, 'package.json')
+
+const fs = new FS()
+
+describe('release.js', async () => {
+	await fs.connect()
+	const tempDir = 'tmp/release'
+	const db = fs.extract(tempDir)
+	await db.writeDocument('package.json', {
+		name: 'test-package',
+		version: '0.0.1-test',
+	})
+
+	// Mock process.cwd to return tempDir
+	const originalCwd = process.cwd
+	process.cwd = () => tempDir
+
+	it('main function processes release command', async () => {
+		// Test with ignore flags to avoid actual git operations
+		const result = await main(['--ignore-uncommitted', '--ignore-fail-tests', '--ignore-tag'])
+		assert.ok(result.includes('Release completed'))
+	})
+
+	it('main function processes prepare command', async () => {
+		const resultP = await main(['prepare'])
+		assert.ok(result.includes('Prepare completed'))
+	})
+
+	it('ReleaseCommand handles package.json validation', async () => {
+		// Create a package.json without required scripts
+		writeFileSync(
+			tempPackageJson,
+			JSON.stringify({
+				name: 'test-package',
+				version: '0.0.1-test',
+			}),
+		)
+
+		// Should exit with error when missing scripts
+		try {
+			await main(['--ignore-uncommitted', '--ignore-fail-tests', '--ignore-tag'])
+			assert.fail('Should have exited with error')
+		} catch (err) {
+			assert.ok(err.message.includes('Missing required scripts'))
+		}
+
+		// Should fix when --fix flag is used
+		const result = await main([
+			'--ignore-uncommitted',
+			'--ignore-fail-tests',
+			'--ignore-tag',
+			'--fix',
+		])
+		assert.ok(result.includes('Release completed'))
+
+		// Verify package.json was fixed
+		const pkg = JSON.parse(readFileSync(tempPackageJson, 'utf8'))
+		assert.ok(pkg.scripts.dev)
+		assert.ok(pkg.scripts.build)
+		assert.ok(pkg.scripts.preview)
+		assert.ok(pkg.scripts.test)
+		assert.ok(pkg.scripts.clean)
+		assert.ok(pkg.devDependencies.husky)
+	})
+
+	// Cleanup
+	process.cwd = originalCwd
+	await db.dropDocument('package.json')
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nan0web/release",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Project Management as Code, Git-Native, GPG-Signed, Test-Driven",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -10,23 +10,31 @@
     "release": "./bin/nan0release.js"
   },
   "dependencies": {
-    "@nan0web/log": "3.1.0",
-    "@nan0web/co": "3.1.0",
-    "@nan0web/markdown": "3.1.0",
-    "@nan0web/db-fs": "3.1.0",
-    "@nan0web/types": "3.1.0",
-    "@nan0web/changelog": "3.1.0",
-    "@nan0web/db": "3.1.0",
-    "@nan0web/ui": "3.1.0",
-    "@nan0web/logos": "3.1.0",
-    "@nan0web/ui-cli": "3.1.0"
+    "@nan0web/co": "3.2.0",
+    "@nan0web/db": "3.2.0",
+    "@nan0web/ui": "3.2.0",
+    "@nan0web/types": "3.2.0",
+    "@nan0web/db-fs": "3.2.0",
+    "@nan0web/log": "3.2.0",
+    "@nan0web/markdown": "3.2.0",
+    "@nan0web/changelog": "3.2.0",
+    "@nan0web/ui-cli": "3.2.0",
+    "@nan0web/logos": "3.2.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "husky": "^9.1.7",
     "knip": "^5.86.0",
-    "@nan0web/test": "3.1.0"
+    "@nan0web/test": "3.2.0"
   },
+  "files": [
+    "bin",
+    "src",
+    "types",
+    "data",
+    "LICENSE",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf .cache/ && rm -rf dist/",

package/src/README.md.js

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises'
 import FS from '@nan0web/db-fs'
 import { NoConsole } from '@nan0web/log'
 import { DatasetParser, DocsParser, runSpawn } from '@nan0web/test'
-import { App } from './index.js'
+import { ReleaseApp } from './index.js'
 import Release from './Release.js'
 import ReleaseDocument from './Release/Document.js'
 import Person from './Release/Person.js'
@@ -103,7 +103,7 @@ function testRender() {
 		 * nan0release init v1.0.0
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**
@@ -134,7 +134,7 @@ function testRender() {
 		 * nan0release list [--json]
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**
@@ -147,7 +147,7 @@ function testRender() {
 		 * nan0release chat write --user alice "Issue with the build pipeline"
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**
@@ -160,7 +160,7 @@ function testRender() {
 		 * nan0release host [--webui] [--port 3000]
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**
@@ -173,7 +173,7 @@ function testRender() {
 		 * nan0release serve [--port 8080]
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**
@@ -204,7 +204,7 @@ function testRender() {
 		 * nan0release seal [--message "All core APIs are stable and tested"]
 		 * ```
 		 */
-		assert.ok(new App().constructor.command.options)
+		assert.ok(new ReleaseApp().constructor.command.options)
 	})
 
 	/**

package/src/Release/MarkdownToTest.test.js

@@ -0,0 +1,60 @@
+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/Release/Scanner.close.test.js

@@ -0,0 +1,91 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import Scanner from './Scanner.js'
+
+const TMP = join(tmpdir(), 'nan0release-close-test-' + Date.now())
+
+describe('Scanner.close()', () => {
+	beforeEach(() => {
+		mkdirSync(TMP, { recursive: true })
+	})
+
+	afterEach(() => {
+		rmSync(TMP, { recursive: true, force: true })
+	})
+
+	it('renames spec → test for a specific version', () => {
+		const dir = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// contract')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 1)
+		assert.ok(!existsSync(join(dir, 'task.spec.js')), 'spec should be gone')
+		assert.ok(existsSync(join(dir, 'task.test.js')), 'test should exist')
+	})
+
+	it('renames multiple spec files in the same version', () => {
+		const dir = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// contract 1')
+		writeFileSync(join(dir, 'api.spec.js'), '// contract 2')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 2)
+		assert.ok(existsSync(join(dir, 'task.test.js')))
+		assert.ok(existsSync(join(dir, 'api.test.js')))
+	})
+
+	it('returns 0 when no specs found for version', () => {
+		mkdirSync(join(TMP, 'releases/1/0/v1.0.0'), { recursive: true })
+		writeFileSync(join(TMP, 'releases/1/0/v1.0.0/task.test.js'), '// already closed')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v1.0.0')
+
+		assert.equal(result.closed, 0)
+	})
+
+	it('throws when version not found', () => {
+		mkdirSync(join(TMP, 'releases'), { recursive: true })
+
+		const scanner = new Scanner(TMP)
+		assert.throws(() => scanner.close('v9.9.9'), /not found/i)
+	})
+
+	it('works with flat structure (releases/v2.0.0/)', () => {
+		const dir = join(TMP, 'releases/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// flat')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 1)
+		assert.ok(existsSync(join(dir, 'task.test.js')))
+	})
+
+	it('close --all renames all specs across versions', () => {
+		const v1 = join(TMP, 'releases/1/0/v1.0.0')
+		const v2 = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(v1, { recursive: true })
+		mkdirSync(v2, { recursive: true })
+		writeFileSync(join(v1, 'task.spec.js'), '// v1')
+		writeFileSync(join(v2, 'task.spec.js'), '// v2')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close()
+
+		assert.equal(result.closed, 2)
+		assert.ok(existsSync(join(v1, 'task.test.js')))
+		assert.ok(existsSync(join(v2, 'task.test.js')))
+	})
+})

package/src/Release/Scanner.test.js

@@ -0,0 +1,134 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import Scanner from './Scanner.js'
+
+const TMP = join(tmpdir(), 'nan0release-scanner-test-' + Date.now())
+
+describe('Scanner', () => {
+	beforeEach(() => {
+		mkdirSync(TMP, { recursive: true })
+	})
+
+	afterEach(() => {
+		rmSync(TMP, { recursive: true, force: true })
+	})
+
+	describe('nested version structure', () => {
+		it('finds spec files in nested directories (releases/1/0/v1.0.0/)', () => {
+			const dir = join(TMP, 'releases/1/0/v1.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.spec.js'), '// spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v1.0.0')
+			assert.ok(specs[0].path.endsWith('task.spec.js'))
+		})
+
+		it('finds test files (closed contracts)', () => {
+			const dir = join(TMP, 'releases/1/0/v1.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.test.js'), '// test')
+
+			const scanner = new Scanner(TMP)
+			const tests = scanner.findTests()
+
+			assert.equal(tests.length, 1)
+			assert.equal(tests[0].version, 'v1.0.0')
+		})
+
+		it('finds flat structure too (releases/v2.0.0/)', () => {
+			const dir = join(TMP, 'releases/v2.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.spec.js'), '// spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v2.0.0')
+		})
+	})
+
+	describe('multiple versions', () => {
+		it('finds all specs across multiple versions', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.spec.js'), '// v1 spec')
+			writeFileSync(join(v2, 'task.spec.js'), '// v2 spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 2)
+			const versions = specs.map((s) => s.version).sort()
+			assert.deepEqual(versions, ['v1.0.0', 'v2.0.0'])
+		})
+
+		it('separates specs from tests', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.test.js'), '// closed')
+			writeFileSync(join(v2, 'task.spec.js'), '// wip')
+
+			const scanner = new Scanner(TMP)
+			assert.equal(scanner.findSpecs().length, 1)
+			assert.equal(scanner.findTests().length, 1)
+		})
+	})
+
+	describe('filter by version', () => {
+		it('finds specs for a specific version', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.spec.js'), '// v1')
+			writeFileSync(join(v2, 'task.spec.js'), '// v2')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs('v2.0.0')
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v2.0.0')
+		})
+	})
+
+	describe('status', () => {
+		it('returns status for all versions', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.test.js'), '// closed')
+			writeFileSync(join(v2, 'task.spec.js'), '// wip')
+
+			const scanner = new Scanner(TMP)
+			const status = scanner.status()
+
+			assert.equal(status.length, 2)
+			const v1s = status.find((s) => s.version === 'v1.0.0')
+			const v2s = status.find((s) => s.version === 'v2.0.0')
+			assert.equal(v1s.state, 'closed')
+			assert.equal(v2s.state, 'wip')
+		})
+	})
+
+	describe('empty releases', () => {
+		it('returns empty arrays when no releases directory', () => {
+			const scanner = new Scanner(TMP)
+			assert.deepEqual(scanner.findSpecs(), [])
+			assert.deepEqual(scanner.findTests(), [])
+		})
+	})
+})

package/src/architecture/ProjectManagementAsCode.test.js

@@ -0,0 +1,128 @@
+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/domain/App.js

@@ -6,8 +6,9 @@ import DepsCommand from './DepsCommand.js'
 import PublishCommand from './PublishCommand.js'
 import SpecCommand from './SpecCommand.js'
 import StatusCommand from './StatusCommand.js'
+import BumpCommand from './BumpCommand.js'
 
-export class App extends ModelAsApp {
+export class ReleaseApp extends ModelAsApp {
 	static command = {
 		help: 'Subcommand to run',
 		options: [
@@ -18,12 +19,14 @@ export class App extends ModelAsApp {
 			PublishCommand,
 			SpecCommand,
 			StatusCommand,
+			BumpCommand,
 		],
+		positional: true,
 		default: null,
 	}
 
 	/**
-	 * @param {Partial<App>} [data]
+	 * @param {Partial<ReleaseApp>} [data]
 	 * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options]
 	 */
 	constructor(data = {}, options = {}) {

package/src/domain/BumpCommand.js

@@ -0,0 +1,137 @@
+import { ModelAsApp, result, show } from '@nan0web/ui'
+import { runSpawn } from '@nan0web/test'
+
+/**
+ * Command to bump the version of changed packages in the monorepo.
+ */
+export default class BumpCommand extends ModelAsApp {
+	static version = {
+		help: 'Target version to set',
+		default: '3.1.1',
+		positional: true,
+	}
+	static since = {
+		help: 'Git reference to diff against',
+		default: 'v3.1.0',
+		positional: true,
+	}
+	static dryRun = {
+		alias: 'dry-run',
+		default: false,
+		help: 'Run the command without making any changes',
+	}
+	static UI = {
+		title: 'bump',
+		help: 'Bump version of changed packages in the monorepo',
+		bumping: 'Bumping {name} version: {oldVersion} -> {targetVersion} ({dir})',
+		skippingAlreadyAtVersion: 'Skipping the same version in {name} version: {version} ({dir})',
+		foundChangedPackages: 'Found {count} changed packages:',
+		detectingChangedPackages:
+			'Detecting changed packages since {sinceRef} for bumping to {targetVersion}...',
+		noChangesDetected: 'No package changes detected.',
+		errorDb: 'Database not initialized',
+	}
+
+	/**
+	 * @param {Partial<BumpCommand>} [data]
+	 * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, options)
+		/** @type {string} Target version */ this.version
+		/** @type {string} Since reference */ this.since
+		/** @type {boolean} Dry run */ this.dryRun
+	}
+
+	/**
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
+	 */
+	async *run() {
+		const { db, t } = this._
+		if (!db) {
+			throw new Error(BumpCommand.UI.errorDb)
+		}
+
+		if (this.help) {
+			return yield* super.run()
+		}
+
+		const targetVersion = this.version || '3.1.1'
+		const sinceRef = this.since || 'v3.1.0'
+
+		yield show(
+			t(BumpCommand.UI.detectingChangedPackages, {
+				sinceRef,
+				targetVersion,
+			})
+		)
+
+		const allFiles = new Set()
+
+		const addFilesFromCommand = async (cmd, args) => {
+			const res = await runSpawn(cmd, args)
+			if (res.code === 0) {
+				res.text
+					.split('\n')
+					.map((f) => f.trim())
+					.filter(Boolean)
+					.forEach((f) => allFiles.add(f))
+			}
+		}
+
+		// 1. Files modified since the release tag
+		await addFilesFromCommand('git', ['diff', '--name-only', sinceRef])
+		// 2. Unstaged changes in the working tree
+		await addFilesFromCommand('git', ['diff', '--name-only'])
+		// 3. Staged changes
+		await addFilesFromCommand('git', ['diff', '--cached', '--name-only'])
+
+		const changedPackages = new Set()
+		for (const file of allFiles) {
+			const parts = file.split('/')
+			if (parts.length >= 2 && (parts[0] === 'packages' || parts[0] === 'apps')) {
+				changedPackages.add(`${parts[0]}/${parts[1]}`)
+			}
+		}
+
+		if (changedPackages.size === 0) {
+			yield show(t(BumpCommand.UI.noChangesDetected), 'warn')
+			return result({})
+		}
+
+		yield show(t(BumpCommand.UI.foundChangedPackages, { count: changedPackages.size }))
+
+		for (const pkgDir of changedPackages) {
+			const pkgJsonPath = `@app/${pkgDir}/package.json`
+			const pkg = await db.loadDocument(pkgJsonPath, null)
+			if (pkg) {
+				const oldVersion = pkg.version
+				if (oldVersion === targetVersion) {
+					yield show(
+						t(BumpCommand.UI.skippingAlreadyAtVersion, {
+							name: pkg.name,
+							version: targetVersion,
+							dir: pkgDir,
+						}),
+						'info'
+					)
+					continue
+				}
+				pkg.version = targetVersion
+				if (!this.dryRun) {
+					await db.saveDocument(pkgJsonPath, pkg)
+				}
+				yield show(
+					t(BumpCommand.UI.bumping, {
+						name: pkg.name,
+						oldVersion,
+						targetVersion,
+						dir: pkgDir,
+					}),
+					this.dryRun ? 'warn' : 'success'
+				)
+			}
+		}
+		return result({ success: true })
+	}
+}

package/src/index.js

@@ -3,7 +3,12 @@ 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'
+import {
+	ProjectManagement,
+	ReleaseManager,
+	TaskTestSuite,
+	ChangelogTaskManager,
+} from './architecture/ProjectManagementAsCode.js'
 
 export {
 	Release,
@@ -14,10 +19,10 @@ export {
 	ProjectManagement,
 	ReleaseManager,
 	TaskTestSuite,
-	ChangelogTaskManager
+	ChangelogTaskManager,
 }
 
-export { App } from './domain/App.js'
+export { ReleaseApp } from './domain/App.js'
 export { default as InitCommand } from './domain/InitCommand.js'
 export { default as CheckCommand } from './domain/CheckCommand.js'
 export { default as CloseCommand } from './domain/CloseCommand.js'

package/src/releases/1/0/v1.0.2/test.test.js

@@ -0,0 +1,6 @@
+import test from 'node:test'
+import assert from 'node:assert'
+
+test('Sample spec', () => {
+	assert.ok(true)
+})

package/src/releases/1/0/v1.0.3/task.test.js

@@ -0,0 +1,16 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import process from 'node:process'
+
+describe('Release v3.0.0 - Dependency Alignment', () => {
+	it('should have correct versions for @nan0web packages', async () => {
+		const pkgPath = join(process.cwd(), 'package.json')
+		const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
+
+		assert.ok(/^3\.1\.\d+$/.test(pkg.version), 'Version should start with 3.1')
+		assert.ok(/^(\^1\.8\.0|workspace:\*)$/.test(pkg.dependencies['@nan0web/ui']), '@nan0web/ui should be ^1.8.0 or workspace:*')
+		assert.ok(/^(\^2\.9\.0|workspace:\*)$/.test(pkg.dependencies['@nan0web/ui-cli']), '@nan0web/ui-cli should be ^2.9.0 or workspace:*')
+	})
+})

package/types/domain/App.d.ts

@@ -1,14 +1,15 @@
-export class App extends ModelAsApp {
+export class ReleaseApp extends ModelAsApp {
     static command: {
         help: string;
         options: (typeof CheckCommand | typeof StatusCommand)[];
+        positional: boolean;
         default: null;
     };
     /**
-     * @param {Partial<App>} [data]
+     * @param {Partial<ReleaseApp>} [data]
      * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options]
      */
-    constructor(data?: Partial<App>, options?: Partial<import("@nan0web/ui").ModelAsAppOptions>);
+    constructor(data?: Partial<ReleaseApp>, options?: Partial<import("@nan0web/ui").ModelAsAppOptions>);
     /** @type {ModelAsApp} Subcommand to run */ command: ModelAsApp;
 }
 import { ModelAsApp } from "@nan0web/ui";

package/types/domain/BumpCommand.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Command to bump the version of changed packages in the monorepo.
+ */
+export default class BumpCommand extends ModelAsApp {
+    static version: {
+        help: string;
+        default: string;
+        positional: boolean;
+    };
+    static since: {
+        help: string;
+        default: string;
+        positional: boolean;
+    };
+    static dryRun: {
+        alias: string;
+        default: boolean;
+        help: string;
+    };
+    static UI: {
+        title: string;
+        help: string;
+        bumping: string;
+        skippingAlreadyAtVersion: string;
+        foundChangedPackages: string;
+        detectingChangedPackages: string;
+        noChangesDetected: string;
+        errorDb: string;
+    };
+    /**
+     * @param {Partial<BumpCommand>} [data]
+     * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options]
+     */
+    constructor(data?: Partial<BumpCommand>, options?: Partial<import("@nan0web/ui").ModelAsAppOptions>);
+    /** @type {string} Target version */ version: string;
+    /** @type {string} Since reference */ since: string;
+    /** @type {boolean} Dry run */ dryRun: boolean;
+}
+import { ModelAsApp } from '@nan0web/ui';

package/types/index.d.ts

@@ -1,4 +1,4 @@
-export { App } from "./domain/App.js";
+export { ReleaseApp } from "./domain/App.js";
 export { default as InitCommand } from "./domain/InitCommand.js";
 export { default as CheckCommand } from "./domain/CheckCommand.js";
 export { default as CloseCommand } from "./domain/CloseCommand.js";

package/knip.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://unpkg.com/knip@5/schema.json",
-  "entry": [
-    "src/index.js",
-    "bin/nan0release.js",
-    "src/README.md.js"
-  ],
-  "project": ["src/**/*.js", "bin/*.js"],
-  "ignoreDependencies": [
-    "@nan0web/log",
-    "@nan0web/ui",
-    "@nan0web/ui-cli",
-    "@nan0web/logos",
-    "@nan0web/markdown",
-    "@nan0web/db",
-    "@nan0web/db-fs",
-    "@nan0web/types",
-    "@nan0web/co",
-    "@nan0web/changelog"
-  ]
-}

package/nan0web.nan0

@@ -1,16 +0,0 @@
-name: "@nan0web/release"
-agents:
-  - id: 'release-manager'
-    description: 'Release & NPM Publication Manager'
-    workflows:
-      - 'src/agents/workflows/release.md'
-      - 'src/agents/workflows/npm-release.md'
-    inspectors:
-      - 'src/agents/inspectors/package-hygiene.md'
-  - id: 'git-reviewer'
-    description: 'Architectural Git Commit Validator'
-    workflows:
-      - 'src/agents/workflows/commit.md'
-      - 'src/agents/workflows/zero-tolerance-git.md'
-    inspectors:
-      - 'src/agents/inspectors/git-reviewer.md'

package/project.yaml

@@ -1,79 +0,0 @@
----
-metadata:
-  description: ""
-  tags: []
-  status: planned
-  locale: uk
-sections:
-  - title: "🧭 Фаза 1: Філософія та Абстракція (The Seed)"
-    content:
-      - "**Місія:** Управління проєктами як код (Project Management as Code). Ми відмовляємось від зовнішніх трекерів задач (Jira, Trello). Проєкт — це набір технічних **контрактів**, які проходять шлях від наміру до імплементації, забезпечуючи реальний статус прогресу автоматично."
-      - "**Базова Абстракція:** Пакет відповідає за логіку та CLI, яка читає Markdown, генерує контракти (`.spec.js`), а потім закриває їх як тести (`.test.js`) з подальшою вічною регресією (тести копіюються в кодову базу)."
-      - "**Глосарій:**"
-      - "- **Release Document**: `release.md` з ТЗ та відомостями про команду."
-      - "- **WIP Контракт**: `*.spec.js`, який падає/у стані `todo`, доки задачу не взяли і не зробили. Оновлює прогрес автоматично при виконанні."
-      - "- **Закритий Контракт**: `*.test.js` (результат команди `close`). Він стає законом і гарантує регресію через `pnpm test`."
-      - "---"
-    tasks: []
-  - title: "📐 Фаза 2: Доменне Моделювання (Data-Driven Models)"
-    content:
-      - "Сутності і моделі, які керують процесом релізу, не мають жорсткої прив'язки до вебу, але описуються як чисті об'єкти:"
-      - "- `Release`: Координує стан (версія, час початку, час завершення)."
-      - "- `ReleaseDocument`: Структурує Markdown у модель (дістає задачі)."
-      - "- `Person`: Типізована перевірка того, хто схвалив дії (через GPG або JSON підпис)."
-      - "- `Scanner`: Абстракція доступу до файлової системи (`releases/`)."
-      - "Статуси відстежуються динамічно через статус тестів: `it.todo` -> `it.skip` -> `it()`."
-      - "---"
-    tasks: []
-  - title: "🛠 Фаза 3: Верифікація Логіки (CLI-First)"
-    content:
-      - "Уся бізнес-логіка @nan0web/release 100% покривається Unit-тестами та CLI командами. Жодного веб-коду. Використовуємо Message-based архітектуру `@nan0web/ui-cli`."
-      - "1. **Команди CLI (`bin/nan0release.js`):**"
-      - "- `deps`, `publish` (реалізовані)."
-      - "- Заплановані (`init`, `spec`, `close`, `status`) інкапсулюють керування `Scanner` та `Release` моделями."
-      - "2. **Contract Lifecycle (Автоматизація прогресу):**"
-      - "- На старті `.spec.js` мають `it.todo()` → задача в беклозі."
-      - "- Коли розробник бере задачу → генерує логіку, змінює на `it()`. При коміті реальний прогрес проекту видно \"зеленим\"."
-      - "- `nan0release close` перейменовує `spec → test` і переносить його в `src/releases/` для 100% автоматичної регресії."
-      - "---"
-    tasks: []
-  - title: "🪐 Фаза 4: Sovereign Workbench (The Master IDE)"
-    content:
-      - "_(Для цього пакету застосовується опціонально, оскільки тут CLI-First)_"
-      - "Пакет `release` є постачальником даних для інших Sandbox-середовищ, де може виводитись:"
-      - "- Dashboard релізу (таблиці статусів `wip/closed/mixed`)."
-      - "- Для цього ми генеруємо `.datasets/README.dataset.jsonl` за допомогою `test:docs`, щоб створювати машиночитабельні знання для LLM-агентів для донавчання або можна користуватись README.md як індексу у реальному часі."
-      - "---"
-    tasks: []
-  - title: "🎨 Фаза 5: Тематизація та Інтерфейс (Theming)"
-    content:
-      - "_(Може застосовуватися при запуску HTML звітів про реліз або Dashboard)_"
-      - "Логіка `release UI` (якщо така з'явиться у додатку `@nan0web/release.app`), буде імпортувати компоненти з `@nan0web/ui-lit` зі строгим слідуванням CSS-змінним (напр. `--co` для кольорів бренду) без створення кастомних стилів."
-      - "---"
-    tasks: []
-  - title: "🏁 Чек-лист готовності пакету (Definition of Done)"
-    content: []
-    tasks:
-      - title: "General"
-        content: []
-        items:
-          - text: "Визначена місія та філософія у `system.md` та `project.md`."
-            completed: true
-          - text: "Робота з Markdown-нотатками та базова доменна логіка (`Scanner`, `Release`)."
-            completed: true
-          - text: "Атомарна операція закриття контрактів (`Scanner.close()`)."
-            completed: true
-          - text: "Всі існуючі специфікації проходять через CLI та `node:test` (22/24 pass, 2 skip)."
-            completed: true
-          - text: "Прогрес автоматизується зміною статусу `spec.js` (todo/skip/pass)."
-            completed: true
-          - text: "Усі CLI сценарії для AGRP (spec, close, init, status) завершені."
-            completed: false
-          - text: "Створені API-ендпоінти для відображення релізного прогресу у React-Dashboard."
-            completed: false
-        total: 7
-        completed: 5
-stats:
-  totalTasks: 7
-  completedTasks: 5
-  progress: 71