agentic-workflow-manager 2.1.0 → 3.0.0

package/dist/src/ui/picker.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_SENTINEL = void 0;
+exports.parseKey = parseKey;
+exports.pickerReducer = pickerReducer;
+exports.multiselectPicker = multiselectPicker;
+const picker_view_1 = require("./picker-view");
+const registry_view_1 = require("../utils/registry-view");
+// ALL_SENTINEL: single source of truth lives in registry-view.ts — re-exported here.
+exports.ALL_SENTINEL = registry_view_1.ALL_SENTINEL;
+function parseKey(data) {
+    switch (data) {
+        case '\x1b[A': return { action: 'up' };
+        case '\x1b[B': return { action: 'down' };
+        case '\r':
+        case '\n': return { action: 'confirm' };
+        case ' ': return { action: 'toggle' };
+        case '\t': return { action: 'toggleAll' };
+        case '\x7f':
+        case '\b': return { action: 'backspace' };
+        case '\x03': return { action: 'cancel' }; // Ctrl-C
+        case '\x1b': return { action: 'clearOrCancel' }; // Esc
+    }
+    if (data.length === 1 && /[a-zA-Z0-9-]/.test(data))
+        return { action: 'char', char: data };
+    return { action: 'none' };
+}
+function realValues(state) {
+    return state.items.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+}
+function pickerReducer(state, key) {
+    const vis = (0, picker_view_1.visibleItems)(state);
+    switch (key.type) {
+        case 'up': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor - 1 + vis.length) % vis.length };
+        }
+        case 'down': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor + 1) % vis.length };
+        }
+        case 'toggle': {
+            if (vis.length === 0)
+                return state;
+            const item = vis[Math.max(0, Math.min(state.cursor, vis.length - 1))];
+            const selected = new Set(state.selected);
+            if (item.value === exports.ALL_SENTINEL) {
+                const reals = realValues(state);
+                const allSel = reals.every((v) => selected.has(v));
+                if (allSel) {
+                    reals.forEach((v) => selected.delete(v));
+                    selected.delete(exports.ALL_SENTINEL);
+                }
+                else {
+                    reals.forEach((v) => selected.add(v));
+                    selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            else {
+                if (selected.has(item.value)) {
+                    selected.delete(item.value);
+                    selected.delete(exports.ALL_SENTINEL); // no longer all-selected
+                }
+                else {
+                    selected.add(item.value);
+                    // if every real item is now selected, also mark the sentinel
+                    const reals = realValues(state);
+                    if (reals.every((v) => selected.has(v)))
+                        selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            return { ...state, selected };
+        }
+        case 'toggleAll': {
+            const reals = vis.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+            const selected = new Set(state.selected);
+            const allSel = reals.every((v) => selected.has(v));
+            if (allSel) {
+                reals.forEach((v) => selected.delete(v));
+                selected.delete(exports.ALL_SENTINEL);
+            }
+            else {
+                reals.forEach((v) => selected.add(v));
+                selected.add(exports.ALL_SENTINEL);
+            }
+            return { ...state, selected };
+        }
+        case 'filterChar':
+            return { ...state, filter: state.filter + key.char, cursor: 0 };
+        case 'backspace':
+            return { ...state, filter: state.filter.slice(0, -1), cursor: 0 };
+    }
+}
+function defaultIO() {
+    return { input: process.stdin, output: process.stdout };
+}
+/**
+ * Interactive multiselect. Returns the selected values, or null if cancelled.
+ * Streams are injectable for testing. Always restores terminal state on exit.
+ */
+function multiselectPicker(opts, io = defaultIO()) {
+    return new Promise((resolve) => {
+        let state = {
+            title: opts.title,
+            items: opts.items,
+            selected: new Set(opts.initialSelected ?? []),
+            cursor: 0,
+            filter: '',
+        };
+        let lastLineCount = 0;
+        const size = () => ({
+            columns: io.output.columns ?? 80,
+            rows: io.output.rows ?? 24,
+        });
+        const draw = () => {
+            const lines = (0, picker_view_1.renderPicker)(state, size());
+            // Move up over the previous frame and clear downward.
+            if (lastLineCount > 0)
+                io.output.write(`\x1b[${lastLineCount}A`);
+            io.output.write('\x1b[0J');
+            io.output.write(lines.join('\n') + '\n');
+            lastLineCount = lines.length;
+        };
+        let onSigint;
+        const cleanup = () => {
+            io.input.removeListener('data', onData);
+            if (onSigint)
+                process.removeListener('SIGINT', onSigint);
+            try {
+                io.input.setRawMode?.(false);
+            }
+            catch { /* best-effort: terminal may not support raw mode */ }
+            io.input.pause?.();
+            io.output.write('\x1b[?25h'); // show cursor
+        };
+        const onData = (chunk) => {
+            const key = parseKey(chunk.toString());
+            switch (key.action) {
+                case 'confirm':
+                    cleanup();
+                    resolve(Array.from(state.selected));
+                    return;
+                case 'cancel':
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'clearOrCancel':
+                    if (state.filter) {
+                        state = { ...state, filter: '', cursor: 0 };
+                        break;
+                    }
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'up':
+                    state = pickerReducer(state, { type: 'up' });
+                    break;
+                case 'down':
+                    state = pickerReducer(state, { type: 'down' });
+                    break;
+                case 'toggle':
+                    state = pickerReducer(state, { type: 'toggle' });
+                    break;
+                case 'toggleAll':
+                    state = pickerReducer(state, { type: 'toggleAll' });
+                    break;
+                case 'backspace':
+                    state = pickerReducer(state, { type: 'backspace' });
+                    break;
+                case 'char':
+                    state = pickerReducer(state, { type: 'filterChar', char: key.char });
+                    break;
+                case 'none': return; // ignore, no redraw
+            }
+            draw();
+        };
+        onSigint = () => {
+            cleanup();
+            resolve(null);
+        };
+        process.once('SIGINT', onSigint);
+        try {
+            io.input.setRawMode?.(true);
+        }
+        catch { /* best-effort: degrade if raw mode unsupported */ }
+        io.input.resume?.();
+        io.input.setEncoding?.('utf8');
+        io.output.write('\x1b[?25l'); // hide cursor
+        io.input.on('data', onData);
+        draw();
+    });
+}

package/dist/src/ui/text.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.displayWidth = displayWidth;
+exports.truncate = truncate;
+exports.wrap = wrap;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2300 && cp <= 0x23ff) || // misc technical (⏎ etc.)
+        (cp >= 0x2600 && cp <= 0x27bf) || // misc symbols / dingbats
+        (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
+        (cp >= 0xff00 && cp <= 0xffef) || // Fullwidth Latin/symbols
+        (cp >= 0x1f000 && cp <= 0x1faff) // emoji
+    );
+}
+/** Visible terminal cells, ignoring ANSI color and treating known wide glyphs as 2. */
+function displayWidth(s) {
+    const plain = stripAnsi(s);
+    let w = 0;
+    for (const ch of plain) {
+        const cp = ch.codePointAt(0);
+        if (cp === 0xfe0f)
+            continue; // variation selector — zero width
+        w += isWide(cp) ? 2 : 1;
+    }
+    return w;
+}
+/** Truncate plain text to `width` cells, appending '…'. Strips ANSI — color AFTER truncating. */
+function truncate(s, width) {
+    if (width <= 0)
+        return '';
+    const plain = stripAnsi(s);
+    if (displayWidth(plain) <= width)
+        return plain;
+    if (width === 1)
+        return '…';
+    let out = '';
+    let w = 0;
+    for (const ch of plain) {
+        const cw = displayWidth(ch);
+        if (w + cw > width - 1)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return out + '…';
+}
+/** Word-wrap plain text to `width` cells. Long single words are not split (acceptable). */
+function wrap(s, width) {
+    if (width <= 0)
+        return [s];
+    const words = stripAnsi(s).split(/\s+/).filter(Boolean);
+    const lines = [];
+    let cur = '';
+    for (const word of words) {
+        if (cur === '') {
+            cur = word;
+            continue;
+        }
+        if (displayWidth(cur) + 1 + displayWidth(word) <= width)
+            cur += ' ' + word;
+        else {
+            lines.push(cur);
+            cur = word;
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines.length ? lines : [''];
+}

package/dist/src/ui/tty.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteractive = isInteractive;
+exports.terminalSize = terminalSize;
+/** True only when both ends are TTYs — the precondition for the interactive picker. */
+function isInteractive() {
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+/** Current terminal size, with a safe 80x24 fallback when undefined (non-TTY). */
+function terminalSize() {
+    return {
+        columns: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    };
+}

package/dist/src/utils/registry-view.js

@@ -10,11 +10,12 @@ exports.packageSummaryLines = packageSummaryLines;
 exports.packageDetailLines = packageDetailLines;
 exports.findPackage = findPackage;
 exports.artifactValue = artifactValue;
-exports.buildLevel1Options = buildLevel1Options;
-exports.buildLevel2Options = buildLevel2Options;
+exports.packagePickerItems = packagePickerItems;
+exports.artifactPickerItems = artifactPickerItems;
 exports.resolveLevel2Selection = resolveLevel2Selection;
 const picocolors_1 = __importDefault(require("picocolors"));
 const registries_1 = require("../core/registries");
+const text_1 = require("../ui/text");
 exports.STANDALONE_NAME = 'standalone';
 function makePackage(name, description, isStandalone, visibility, artifacts) {
     return {
@@ -73,7 +74,7 @@ function artifactCountLabel(counts) {
 function packageIcon(pkg) {
     return pkg.isStandalone ? '🔹' : '📦';
 }
-function packageSummaryLines(packages) {
+function packageSummaryLines(packages, width) {
     const uniqueSkillNames = new Set(packages.flatMap((p) => p.artifacts.filter((a) => a.type === 'skill').map((a) => a.name)));
     const totalSkills = uniqueSkillNames.size;
     const lines = [`AWM Registry — ${plural(packages.length, 'package')}, ${plural(totalSkills, 'skill')}`, ''];
@@ -83,12 +84,17 @@ function packageSummaryLines(packages) {
     packages.forEach((p, i) => {
         const name = p.name.padEnd(nameWidth);
         const count = countLabels[i].padEnd(countWidth);
-        const desc = p.isStandalone ? '' : p.description;
+        let desc = p.isStandalone ? '' : p.description;
+        if (width && desc) {
+            const used = 3 + nameWidth + 3 + countWidth + 3; // icon(2)+space(1), name, gap, count, gap
+            const avail = width - used;
+            desc = avail > 1 ? (0, text_1.truncate)(desc, avail) : '';
+        }
         lines.push(`${packageIcon(p)} ${name}   ${count}   ${desc}`.trimEnd());
     });
     return lines;
 }
-function packageDetailLines(pkg) {
+function packageDetailLines(pkg, width) {
     const lines = [];
     const header = pkg.isStandalone
         ? `${packageIcon(pkg)} ${pkg.name} — ${plural(pkg.artifacts.length, 'artifact')}`
@@ -99,8 +105,10 @@ function packageDetailLines(pkg) {
             ? picocolors_1.default.yellow(`  ← ${(0, registries_1.registryNameForPath)(a.sourcePath) ?? 'unknown'} (override)`)
             : '';
         lines.push(`  ${TYPE_ICON[a.type]}${a.name}${mark}`);
-        if (a.description)
-            lines.push(`     ${a.description}`);
+        if (a.description) {
+            const desc = width ? (0, text_1.truncate)(a.description, width - 5) : a.description;
+            lines.push(`     ${desc}`);
+        }
     });
     return lines;
 }
@@ -130,21 +138,27 @@ exports.ALL_SENTINEL = '__ALL__';
 function artifactValue(a) {
     return `${a.type}:${a.name}`;
 }
-function buildLevel1Options(packages) {
-    return packages.map((p) => {
-        const count = p.isStandalone ? plural(p.artifacts.length, 'artifact') : artifactCountLabel(p.counts);
-        const desc = p.isStandalone ? '' : ` · ${p.description}`;
-        return { value: p.name, label: `${packageIcon(p)} ${p.name}  ${picocolors_1.default.dim(`${count}${desc}`)}` };
-    });
+function packagePickerItems(packages) {
+    return packages.map((p) => ({
+        value: p.name,
+        label: `${packageIcon(p)} ${p.name}`,
+        description: p.isStandalone
+            ? plural(p.artifacts.length, 'artifact')
+            : `${artifactCountLabel(p.counts)} · ${p.description}`,
+    }));
 }
-function buildLevel2Options(pkg) {
-    const installAll = { value: exports.ALL_SENTINEL, label: `✨ Install entire package (${pkg.artifacts.length})` };
-    const rest = pkg.artifacts.map((a) => {
-        const title = `${TYPE_ICON[a.type]}${a.name}`;
-        const label = a.description ? `${title}\n     ${picocolors_1.default.dim(a.description)}` : title;
-        return { value: artifactValue(a), label };
-    });
-    return [installAll, ...rest];
+function artifactPickerItems(pkg) {
+    const all = {
+        value: exports.ALL_SENTINEL,
+        label: `✨ Install entire package (${pkg.artifacts.length})`,
+        description: 'Select every artifact in this package.',
+    };
+    const rest = pkg.artifacts.map((a) => ({
+        value: artifactValue(a),
+        label: `${TYPE_ICON[a.type]}${a.name}`,
+        description: a.description || '',
+    }));
+    return [all, ...rest];
 }
 function resolveLevel2Selection(pkg, selectedValues) {
     if (selectedValues.includes(exports.ALL_SENTINEL))

package/dist/tests/release/core.test.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("../../src/release/core");
+const rec = (header, body = '') => `${header}${core_1.US}${body}${core_1.RS}`;
+const mk = (type, breaking = false) => ({ type, scope: null, breaking, subject: 's' });
+describe('parseCommits', () => {
+    it('parsea type, scope, subject', () => {
+        const [c] = (0, core_1.parseCommits)(rec('feat(add): nueva flag'));
+        expect(c).toEqual({ type: 'feat', scope: 'add', breaking: false, subject: 'nueva flag' });
+    });
+    it('scope null cuando no hay paréntesis', () => {
+        expect((0, core_1.parseCommits)(rec('fix: corrige bug'))[0].scope).toBeNull();
+    });
+    it('breaking por bang en el header', () => {
+        expect((0, core_1.parseCommits)(rec('feat!: rompe API'))[0].breaking).toBe(true);
+    });
+    it('breaking por footer BREAKING CHANGE en el body', () => {
+        expect((0, core_1.parseCommits)(rec('feat(x): y', 'cuerpo\nBREAKING CHANGE: cambia todo'))[0].breaking).toBe(true);
+    });
+    it('descarta commits no convencionales sin romper', () => {
+        expect((0, core_1.parseCommits)(rec('merge branch foo') + rec('feat: ok'))).toEqual([
+            { type: 'feat', scope: null, breaking: false, subject: 'ok' },
+        ]);
+    });
+    it('entrada vacía → arreglo vacío', () => {
+        expect((0, core_1.parseCommits)('')).toEqual([]);
+    });
+});
+describe('determineBump', () => {
+    it('breaking → major (gana sobre feat/fix)', () => {
+        expect((0, core_1.determineBump)([mk('fix'), mk('feat', true)])).toBe('major');
+    });
+    it('feat sin breaking → minor', () => {
+        expect((0, core_1.determineBump)([mk('fix'), mk('feat')])).toBe('minor');
+    });
+    it('fix o perf → patch', () => {
+        expect((0, core_1.determineBump)([mk('fix')])).toBe('patch');
+        expect((0, core_1.determineBump)([mk('perf')])).toBe('patch');
+    });
+    it('solo docs/chore/refactor → null (nada releasable)', () => {
+        expect((0, core_1.determineBump)([mk('docs'), mk('chore'), mk('refactor')])).toBeNull();
+    });
+    it('lista vacía → null', () => {
+        expect((0, core_1.determineBump)([])).toBeNull();
+    });
+});
+describe('nextVersion', () => {
+    it('major resetea minor y patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'major')).toBe('3.0.0');
+    });
+    it('minor resetea patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'minor')).toBe('2.2.0');
+    });
+    it('patch incrementa patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'patch')).toBe('2.1.2');
+    });
+    it('tolera espacios alrededor', () => {
+        expect((0, core_1.nextVersion)('  2.1.1  ', 'patch')).toBe('2.1.2');
+    });
+    it.each(['', '.', '..', 'x.y.z', '2.1', '2.1.1.0'])('rechaza base inválida %p', (bad) => {
+        expect(() => (0, core_1.nextVersion)(bad, 'patch')).toThrow(/invalid base version/i);
+    });
+});
+describe('selectFloor', () => {
+    it('sin tag → usa la versión del package.json', () => {
+        expect((0, core_1.selectFloor)('2.1.1', null)).toBe('2.1.1');
+    });
+    it('package.json mayor que el tag → gana package.json (caso drift real)', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '1.0.0')).toBe('2.1.1');
+    });
+    it('tag mayor que package.json → gana el tag', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '2.5.0')).toBe('2.5.0');
+    });
+    it('iguales → ese valor', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '2.1.1')).toBe('2.1.1');
+    });
+    it('rechaza current inválido', () => {
+        expect(() => (0, core_1.selectFloor)('', null)).toThrow(/invalid/i);
+    });
+});
+describe('renderChangelog', () => {
+    const commits = [
+        { type: 'feat', scope: 'add', breaking: false, subject: 'flag --all' },
+        { type: 'fix', scope: null, breaking: false, subject: 'corrige width' },
+        { type: 'chore', scope: null, breaking: true, subject: 'sube node' },
+    ];
+    it('encabeza con versión y fecha', () => {
+        expect((0, core_1.renderChangelog)('2.2.0', '2026-06-25', commits)).toContain('## v2.2.0 - 2026-06-25');
+    });
+    it('agrupa Features, Fixes y Breaking Changes', () => {
+        const md = (0, core_1.renderChangelog)('2.2.0', '2026-06-25', commits);
+        expect(md).toContain('### Features');
+        expect(md).toContain('- **add:** flag --all');
+        expect(md).toContain('### Fixes');
+        expect(md).toContain('- corrige width');
+        expect(md).toContain('### Breaking Changes');
+        expect(md).toContain('- sube node');
+    });
+    it('omite secciones vacías', () => {
+        const md = (0, core_1.renderChangelog)('2.2.1', '2026-06-25', [
+            { type: 'fix', scope: null, breaking: false, subject: 'x' },
+        ]);
+        expect(md).toContain('### Fixes');
+        expect(md).not.toContain('### Features');
+    });
+});