@nan0web/release 1.0.0

package/types/Release.d.ts

@@ -0,0 +1,89 @@
+export default Release;
+export type ReleaseConfig = {
+    /**
+     * - Release version
+     */
+    version?: string | undefined;
+    /**
+     * -
+     */
+    createdAt?: string | number | Date | undefined;
+    /**
+     * -
+     */
+    startAt?: string | number | Date | undefined;
+    /**
+     * -
+     */
+    planAt?: string | number | Date | undefined;
+    /**
+     * -
+     */
+    completeAt?: string | number | Date | undefined;
+    /**
+     * -
+     */
+    document?: string | ReleaseDocument | undefined;
+    /**
+     * - Task map with test functions
+     */
+    tasks?: Map<string, Function> | undefined;
+};
+/**
+ * @typedef {Object} ReleaseConfig
+ * @property {string} [version] - Release version
+ * @property {string | number | Date | undefined} [createdAt] -
+ * @property {string | number | Date | undefined} [startAt] -
+ * @property {string | number | Date | undefined} [planAt] -
+ * @property {string | number | Date | undefined} [completeAt] -
+ * @property {string | ReleaseDocument} [document] -
+ * @property {Map<string, Function>} [tasks] - Task map with test functions
+ */
+/**
+ * Release management class that coordinates task validation and release execution
+ */
+declare class Release {
+    /**
+     * Creates a Release instance
+     * @param {ReleaseConfig} config - Release configuration
+     */
+    constructor(config?: ReleaseConfig);
+    /** @type {string} */
+    version: string;
+    /** @type {Date} */
+    createdAt: Date;
+    /** @type {Date?} */
+    startAt: Date | null;
+    /** @type {Date?} */
+    planAt: Date | null;
+    /** @type {Date?} */
+    completeAt: Date | null;
+    /** @type {Map<string, Function>} */
+    tasks: Map<string, Function>;
+    /** @type {ReleaseDocument} */
+    document: ReleaseDocument;
+    /** @type {Logger} */
+    logger: Logger;
+    get path(): string;
+    /**
+     * Validate release by running all task tests
+     * @returns {Promise<Object>} Validation results
+     */
+    validate(): Promise<any>;
+    /**
+     * Execute release process
+     * @param {Object} options - Release options
+     * @param {boolean} [options.ignoreFailTests=false] - Ignore failed tests
+     * @returns {Promise<boolean>} Release success status
+     */
+    execute(options?: {
+        ignoreFailTests?: boolean | undefined;
+    }): Promise<boolean>;
+    /**
+     * Get release progress statistics
+     * @returns {Promise<Object>} Progress statistics
+     */
+    getProgress(): Promise<any>;
+}
+import ReleaseDocument from "./Release/Document.js";
+import Logger from '@nan0web/log';

package/types/ReleaseCLI.d.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * CLI application for release management
+ */
+export default class ReleaseCLI extends Command {
+    static Message: typeof AppCommandMessage;
+    constructor();
+    /** @type {DB?} */
+    db: DB | null;
+    /** @type {FS} */
+    fs: FS;
+    /** @type {Record<string, Release>} */
+    releases: Record<string, Release>;
+    /** @type {Release?} */
+    current: Release | null;
+    /**
+     * @param {string[] | string} argv
+     * @returns {AppCommandMessage}
+     */
+    parse(argv?: string[] | string): AppCommandMessage;
+    /**
+     * Run CLI application
+     * @param {string[]} argv - Command line arguments
+     * @returns {Promise<void>}
+     */
+    run(argv: string[]): Promise<void>;
+    loadReleaseFiles(): Promise<void>;
+}
+import { Command } from '@nan0web/co';
+import DB from "./db/ReleaseDB.js";
+import FS from "@nan0web/db-fs";
+import Release from './Release.js';
+import AppCommandMessage from './co/AppCommandMessage.js';

package/types/Team.d.ts

@@ -0,0 +1,27 @@
+export default Company;
+declare class Company {
+    static name: string;
+    static c: typeof CLevelTeam;
+    static ux: typeof UXTeam;
+}
+declare class CLevelTeam {
+    static name: string;
+    static ceo: Person;
+    static cfo: Person;
+}
+declare class UXTeam {
+    static name: string;
+    static designer: Person;
+}
+declare class Person {
+    constructor(name: any);
+    /** @type {HumanName} */
+    name: HumanName;
+    /** @type {HumanGender} */
+    gender: HumanGender;
+    /** @type {HumanContact[]} */
+    contacts: HumanContact[];
+}
+import { HumanName } from "@nan0web/verse";
+import { HumanGender } from "@nan0web/verse";
+import { HumanContact } from "@nan0web/verse";

package/types/architecture/ProjectManagementAsCode.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Task management through node:test infrastructure
+ * @class ProjectManagement
+ */
+export class ProjectManagement {
+    /**
+     * Initialize project management system
+     * @param {Object} [config] - Configuration options
+     * @param {string} [config.projectPath] - Path to project root
+     * @param {boolean} [config.autoTrack] - Enable automatic status tracking
+     */
+    constructor(config?: {
+        projectPath?: string | undefined;
+        autoTrack?: boolean | undefined;
+    });
+    /** @type {string} */
+    projectPath: string;
+    /** @type {boolean} */
+    autoTrack: boolean;
+    /**
+     * Task registry mapping task IDs to their test files
+     * @type {Map<string, string>}
+     */
+    tasks: Map<string, string>;
+    /**
+     * Register a task with its validation test
+     * @param {string} taskId - Unique task identifier
+     * @param {string} testFilePath - Path to the test file
+     */
+    registerTask(taskId: string, testFilePath: string): void;
+    /**
+     * Run all registered task tests to determine project status
+     * @returns {Promise<Object>} Test results summary
+     */
+    validateProjectState(): Promise<any>;
+    /**
+     * Execute individual task test
+     * @param {string} testPath - Path to test file
+     * @returns {Promise<Object>} Test execution result
+     */
+    runTaskTest(testPath: string): Promise<any>;
+    /**
+     * Generate release readiness report
+     * @param {string} version - Target version for release
+     * @returns {Promise<Object>} Release validation status
+     */
+    validateRelease(version: string): Promise<any>;
+}
+/**
+ * Release management system that coordinates task validation
+ * @class ReleaseManager
+ */
+export class ReleaseManager {
+    /**
+     * Initialize release manager
+     * @param {ProjectManagement} projectManager - Project management instance
+     */
+    constructor(projectManager: ProjectManagement);
+    /**
+     * @type {ProjectManagement}
+     */
+    projectManager: ProjectManagement;
+    /**
+     * Execute release process with task validation
+     * @param {string} type - Release type (patch, minor, major)
+     * @param {Object} options - Release options
+     * @returns {Promise<Object>} Release execution result
+     */
+    executeRelease(type: string, options?: any): Promise<any>;
+    /**
+     * Calculate next version based on release type
+     * @param {string} type - Release type
+     * @returns {string} Next version string
+     */
+    calculateVersion(type: string): string;
+    /**
+     * Publish release to package registry
+     * @param {string} version - Version to publish
+     * @param {Object} options - Publish options
+     * @returns {Promise<boolean>} Publish success status
+     */
+    publish(version: string, options: any): Promise<boolean>;
+}
+/**
+ * Task test suite definition following node:test format
+ * @extends TestSuite
+ */
+export class TaskTestSuite extends TestSuite {
+    /**
+     * Initialize task test suite
+     * @param {string} taskId - Unique task identifier
+     * @param {string} description - Human-readable task description
+     * @param {Function} testFunction - Test implementation function
+     */
+    constructor(taskId: string, description: string, testFunction: Function);
+    /**
+     * Task ID this test suite validates
+     * @type {string}
+     */
+    taskId: string;
+    /**
+     * Task description for human understanding
+     * @type {string}
+     */
+    description: string;
+}
+/**
+ * Changelog-based task management for LLM-assisted development
+ * @class ChangelogTaskManager
+ */
+export class ChangelogTaskManager {
+    /**
+     * Parse changelog to extract tasks and their statuses
+     * @param {string} changelogContent - Raw changelog markdown
+     * @returns {Array<Object>} Array of task objects
+     */
+    parseChangelog(changelogContent: string): Array<any>;
+    /**
+     * Generate task test files from changelog entries
+     * @param {Array<Object>} tasks - Array of task objects
+     * @returns {Promise<void>}
+     */
+    generateTaskTests(tasks: Array<any>): Promise<void>;
+}
+/**
+ * # Project Management as Code Architecture
+ *
+ * This architecture implements project management through automated testing,
+ * where each task is represented as a test case that validates system behavior.
+ *
+ * ## Core Concepts
+ *
+ * 1. **Tasks as Tests**: Each project task becomes a test suite that validates
+ *    implementation correctness
+ * 2. **Status Tracking**: Task status moves automatically through CI/CD pipeline
+ *    when tests pass/fail
+ * 3. **Release Validation**: Releases are validated by running task tests as
+ *    part of the release process
+ *
+ * ## Implementation Details
+ */
+/**
+ * Base TestSuite class for task management
+ */
+declare class TestSuite {
+    /**
+     * @param {string} name - Suite name
+     * @param {Function} fn - Test function
+     */
+    constructor(name: string, fn: Function);
+    name: string;
+    fn: Function;
+    /**
+     * Run the test suite
+     * @returns {Promise<Object>}
+     */
+    run(): Promise<any>;
+}
+export {};

package/types/co/AppCommandMessage.d.ts

@@ -0,0 +1,12 @@
+export default class AppCommandMessage extends CommandMessage {
+    /**
+     * @param {*} input
+     * @returns {AppCommandMessage}
+     */
+    static from(input: any): AppCommandMessage;
+    set opts(value: AppCommandOptions);
+    /** @returns {AppCommandOptions} */
+    get opts(): AppCommandOptions;
+}
+import { CommandMessage } from "@nan0web/co";
+import AppCommandOptions from "./AppCommandOptions.js";

package/types/co/AppCommandOptions.d.ts

@@ -0,0 +1,23 @@
+export default AppCommandOptions;
+declare class AppCommandOptions {
+    /**
+     * @param {Object} input
+     */
+    constructor(input?: any);
+    /** @type {boolean} */
+    webui: boolean;
+    /** @type {boolean} */
+    json: boolean;
+    /** @type {boolean} */
+    quiet: boolean;
+    /** @type {string} */
+    releaseDir: string;
+    /** @type {boolean} */
+    write: boolean;
+    /** @type {string} */
+    user: string;
+    /** @type {boolean} */
+    ignoreFailTests: boolean;
+    /** @type {boolean} */
+    full: boolean;
+}

package/types/commands/ChatCommand.d.ts

@@ -0,0 +1,20 @@
+export default ChatCommand;
+/**
+ * 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")
+ */
+declare class ChatCommand extends SubCommand {
+    /**
+     * Run the chat command.
+     *
+     * @param {AppCommandMessage} ctx – command context (contains args and opts)
+     */
+    run(ctx: AppCommandMessage): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";
+import AppCommandMessage from "../co/AppCommandMessage.js";

package/types/commands/HostCommand.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 {
+    /**
+     * Run the host server.
+     *
+     * @param {Object} ctx – command context
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/commands/InitCommand.d.ts

@@ -0,0 +1,20 @@
+export default InitCommand;
+/**
+ * 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
+ */
+declare class InitCommand extends SubCommand {
+    /**
+     * Run the init process.
+     *
+     * @param {AppCommandMessage} msg – command context (contains parsed options)
+     */
+    run(msg: AppCommandMessage): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";
+import AppCommandMessage from "../co/AppCommandMessage.js";

package/types/commands/ListCommand.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 {
+    /**
+     * Execute the command.
+     *
+     * @param {Object} ctx – command context (contains parsed args)
+     * @returns {Promise<void>}
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/commands/PublishCommand.d.ts

@@ -0,0 +1,49 @@
+export class PublishCommandOptions {
+    /**
+     * @param {any} input
+     * @returns {PublishCommandOptions}
+     */
+    static from(input: any): PublishCommandOptions;
+    constructor(input?: {});
+    /** @type {string} */
+    tag: string;
+}
+/**
+ * @extends {CommandMessage}
+ */
+export class PublishCommandMessage extends CommandMessage {
+    constructor(input?: {});
+    set opts(value: PublishCommandOptions);
+    /** @returns {PublishCommandOptions} */
+    get opts(): PublishCommandOptions;
+}
+/**
+ * @extends {Command}
+ */
+export default class PublishCommand extends Command {
+    static Message: typeof PublishCommandMessage;
+    constructor(input?: {});
+    /**
+     * @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
+     */
+    run(msg: PublishCommandMessage): Promise<void>;
+    #private;
+}
+import { CommandMessage } from "@nan0web/co";
+import { Command } from "@nan0web/co";

package/types/commands/SealCommand.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 {
+    /**
+     * Seal the current release.
+     *
+     * @param {Object} ctx – command context
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/commands/ServeCommand.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {
+    /**
+     * Start the static server.
+     *
+     * @param {Object} ctx – command context
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/commands/ShowCommand.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 {
+    /**
+     * Render the release information.
+     *
+     * @param {Object} ctx – command context
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/commands/SubCommand.d.ts

@@ -0,0 +1,8 @@
+export default SubCommand;
+declare class SubCommand extends Command {
+    constructor(options?: {});
+    /** @type {ReleaseDB?} */
+    db: ReleaseDB | null;
+}
+import { Command } from '@nan0web/co';
+import ReleaseDB from '../db/ReleaseDB.js';

package/types/commands/ValidateCommand.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 {
+    /**
+     * Execute validation.
+     *
+     * @param {Object} ctx – command context
+     */
+    run(ctx: any): Promise<void>;
+}
+import SubCommand from "./SubCommand.js";

package/types/db/ReleaseDB.d.ts

@@ -0,0 +1,30 @@
+export default ReleaseDB;
+/**
+ * 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").
+ */
+declare class ReleaseDB extends DBFS {
+    /**
+     * @param {object} input
+     * @returns {ReleaseDB}
+     */
+    static from(input: object): ReleaseDB;
+    /**
+     * @param {string} uri
+     * @returns {ReleaseDB}
+     */
+    extract(uri: string): ReleaseDB;
+    /**
+     * @param {string} version
+     * @returns {ReleaseDB}
+     */
+    extractVersion(version: string): ReleaseDB;
+    /**
+     * @returns {Array<string>} List of discovered release root paths
+     */
+    get releases(): Array<string>;
+}
+import DBFS from "@nan0web/db-fs";