agentic-workflow-manager 9.0.2 → 9.1.0

package/dist/tests/integration/process-model-e2e.test.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/integration/process-model-e2e.test.ts
+//
+// Ledger signature: ca1-2-1-3-no-e2e-regression-test.
+//
+// CA-1.2 y CA-1.3 del plan R1a (docs/plans/2026-08-23-process-model-r1a-plan.md)
+// fueron verificados MANUALMENTE varias veces durante esa sesión, pero ningún
+// test permanente los sostenía. Este test cierra ese hueco ejecutando el
+// binario compilado real (dist/src/index.js) contra un AWM_HOME/registry
+// fixture aislado — no llama funciones internas directamente. El plan es
+// explícito: "No vale el test unitario: el criterio dice 'reporta', y eso se
+// prueba ejecutando" (CA-1.2). Sigue el patrón de invocación de
+// tests/structural/r3-cli-major-version.test.ts (spawnSync del dist compilado)
+// y el patrón de fixture de tests/core/process/discover.test.ts +
+// tests/core/process/no-regression.test.ts (registries.json + skills/<name>/SKILL.md
+// bajo un AWM_HOME de tmpdir, nunca el ~/.awm real).
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const CLI_ROOT = path_1.default.resolve(__dirname, '../..');
+const DIST_ENTRYPOINT = path_1.default.join(CLI_ROOT, 'dist', 'src', 'index.js');
+// Fixture canónico del plan R1a, reproducido byte a byte (bloque "Canonical fixture").
+const EJEMPLO_PROCESO_SKILL_MD = `---
+awm: process-model
+schema: 1
+name: ejemplo-proceso
+status: draft
+entry_point: true
+terminates_to: none
+created: 2026-08-23
+updated: 2026-08-23
+---
+
+# Ejemplo
+
+## Objetivo
+
+G — Llevar una idea hasta una rama cerrada.
+
+## Cuándo aplica
+
+Cuando hay una tarea de desarrollo sin plan previo.
+
+## Estructura
+
+- SG-1 — Diseñar
+  - OP-1.1 — Elicitar requisitos
+  - OP-1.2 — Escribir el design doc
+- SG-2 — Ejecutar
+  - OP-2.1 — Implementar por tasks
+
+## Ruteo
+
+| Cuándo | Estado requerido | Va a | Termina en |
+|---|---|---|---|
+| No hay design doc | | OP-1.1 | SG-1 |
+| Design doc aprobado | SG-1 | OP-2.1 | SG-2 |
+
+## Terminación
+
+finishing-a-development-branch
+
+## Sin verificar
+
+Nada.
+`;
+/** Construye AWM_HOME/registries.json + AWM_HOME/registries/<name>/skills/<skill>/SKILL.md
+ *  — el mismo layout que contentRoots() (src/core/registries.ts) resuelve para
+ *  descubrimiento real, sin clonar git: contentRoots() solo necesita que el
+ *  directorio exista y pase inspectRegistrySafety (ningún symlink, ≥1 dir
+ *  administrado). El campo "remote" no se usa en este test — nada corre `awm update`. */
+function fixture() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-process-e2e-'));
+    const project = path_1.default.join(root, 'project');
+    const home = path_1.default.join(root, 'home');
+    const awmHome = path_1.default.join(home, '.awm');
+    const registryRoot = path_1.default.join(awmHome, 'registries', 'baseline');
+    fs_1.default.mkdirSync(project, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills', 'ejemplo-proceso'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ name: 'process-model-e2e-fixture', private: true }));
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.invalid/baseline.git' }]));
+    fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills', 'ejemplo-proceso', 'SKILL.md'), EJEMPLO_PROCESO_SKILL_MD);
+    return { root, project, home, awmHome };
+}
+function runCompiledCli(f, ...args) {
+    const result = (0, child_process_1.spawnSync)(process.execPath, [DIST_ENTRYPOINT, ...args], {
+        cwd: f.project,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: f.home,
+            USERPROFILE: f.home,
+            AWM_HOME: f.awmHome,
+            AWM_NO_UPDATE_CHECK: '1',
+        },
+    });
+    expect(result.error).toBeUndefined();
+    return { code: result.status, stdout: result.stdout, stderr: result.stderr };
+}
+describe('process model E2E against the real built binary (CA-1.2, CA-1.3)', () => {
+    jest.setTimeout(60_000);
+    beforeAll(() => {
+        if (!fs_1.default.existsSync(DIST_ENTRYPOINT)) {
+            throw new Error(`${DIST_ENTRYPOINT} no existe — este test ejecuta el binario compilado real. ` +
+                'Correr `npm run build` antes de `jest` (mismo pre-requisito que tests/structural/r3-cli-major-version.test.ts).');
+        }
+    });
+    let f;
+    beforeEach(() => { f = fixture(); });
+    afterEach(() => { fs_1.default.rmSync(f.root, { recursive: true, force: true }); });
+    test('CA-1.2 — `process list` reporta ejemplo-proceso con su status', () => {
+        const result = runCompiledCli(f, 'process', 'list');
+        expect(result.code).toBe(0);
+        expect(result.stdout).toContain('ejemplo-proceso');
+        expect(result.stdout).toContain('draft');
+    });
+    test('CA-1.2 — `process show ejemplo-proceso --json` emite el modelo parseado completo', () => {
+        const result = runCompiledCli(f, 'process', 'show', 'ejemplo-proceso', '--json');
+        expect(result.code).toBe(0);
+        const model = JSON.parse(result.stdout);
+        expect(model).toEqual(expect.objectContaining({
+            name: 'ejemplo-proceso',
+            schema: 1,
+            status: 'draft',
+            entryPoint: true,
+            terminatesTo: 'none',
+        }));
+        expect(model.body.structure).toEqual([
+            { id: 'SG-1', text: 'Diseñar', operations: [
+                    { id: 'OP-1.1', text: 'Elicitar requisitos' },
+                    { id: 'OP-1.2', text: 'Escribir el design doc' },
+                ] },
+            { id: 'SG-2', text: 'Ejecutar', operations: [
+                    { id: 'OP-2.1', text: 'Implementar por tasks' },
+                ] },
+        ]);
+        expect(model.body.routing).toEqual([
+            { when: 'No hay design doc', requiredState: '', goesTo: 'OP-1.1', endsAt: 'SG-1' },
+            { when: 'Design doc aprobado', requiredState: 'SG-1', goesTo: 'OP-2.1', endsAt: 'SG-2' },
+        ]);
+        expect(model.body.termination).toBe('finishing-a-development-branch');
+        // No source path leaks into the published/consumable view (see publicView
+        // in src/commands/process/index.ts) — assert the field is entirely absent.
+        expect(model).not.toHaveProperty('source');
+    });
+    test('CA-1.3 — `doctor --full` renderiza la seccion Processes desde el adapter, sin re-parseo ad-hoc', () => {
+        const result = runCompiledCli(f, 'doctor', '--full');
+        expect([0, 1]).toContain(result.code);
+        expect(result.stdout).toContain('Processes');
+        // El adapter de producción (productionDashboardAdapters.processes, src/core/dashboard/collect.ts)
+        // construye el id de item como `process.<name>` vía sanitizeDashboardId — esto es lo que
+        // demuestra que la sección viene del adapter real (discoverProcessModels() -> Dashboard),
+        // no de un parser propio del Dashboard.
+        expect(result.stdout).toContain('process.ejemplo-proceso');
+    });
+});

package/dist/tests/structural/process-model-single-parser.test.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const SRC = path_1.default.resolve(__dirname, '../../src');
+/** Módulos autorizados a conocer la sintaxis del modelo. Cualquier otro que la
+ *  toque está reimplementando el parser, que es exactamente lo que R5.2 prohíbe. */
+const PARSER_MODULES = ['core/process/model.ts', 'core/process/body.ts', 'core/process/discover.ts'];
+function sourceFiles(dir) {
+    return fs_1.default.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory())
+            return sourceFiles(full);
+        return entry.isFile() && entry.name.endsWith('.ts') ? [full] : [];
+    });
+}
+// Enmascara comentarios antes de escanear: el JSDoc/prosa de este mismo
+// archivo (y de otros) cita literales como "process-model" o tokens de
+// ejemplo tipo "SG-1" a modo ilustrativo, lo que si no se descartara
+// registraría falsos positivos fantasma — "acá alguien está citando el
+// contrato", no "acá alguien lo está parseando". Strip naive de
+// bloque/línea (no un parser TS completo), igual que en
+// exec-invocation-explicit-stdio.test.ts. A diferencia de ese helper, acá
+// enmascaramos con espacios en vez de borrar: preserva la cantidad de
+// saltos de línea del original, así los números de línea reportados en los
+// offenders siguen apuntando al archivo real. El guard `[^:]` en `//` evita
+// tratar una URL `https://` dentro de una cadena como comentario de línea.
+function stripComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, ' '))
+        .replace(/(^|[^:])(\/\/.*)$/gm, (_full, prefix, comment) => prefix + comment.replace(/[^\n]/g, ' '));
+}
+// El discriminador literal y los headings del contrato son la firma de "acá
+// alguien está parseando el modelo". `\b` ancla SG-\d/OP-\d a límites de
+// palabra para no matchear como substring dentro de tokens no relacionados
+// (MSG-1, WORKSHOP-2, DROP-3 no deben disparar el guard).
+const SIGNATURE_RE = /process-model|##\s+Cuándo aplica|\bSG-\d|\bOP-\d/;
+/** Líneas (1-indexed) del archivo, ya sin comentarios, donde aparece la firma. */
+function signatureLines(content) {
+    return stripComments(content)
+        .split('\n')
+        .flatMap((line, idx) => (SIGNATURE_RE.test(line) ? [idx + 1] : []));
+}
+describe('R5.2 — el CLI parsea el modelo una sola vez', () => {
+    it('ningún módulo fuera de core/process/ conoce la sintaxis del modelo', () => {
+        const offenders = sourceFiles(SRC).flatMap((file) => {
+            const relative = path_1.default.relative(SRC, file).split(path_1.default.sep).join('/');
+            if (PARSER_MODULES.includes(relative))
+                return [];
+            const content = fs_1.default.readFileSync(file, 'utf-8');
+            return signatureLines(content).map((line) => `${relative}:${line}`);
+        });
+        expect(offenders).toEqual([]);
+    });
+    it('el adapter del Dashboard consume el descubridor, no el filesystem', () => {
+        const collect = fs_1.default.readFileSync(path_1.default.join(SRC, 'core/dashboard/collect.ts'), 'utf-8');
+        expect(collect).toContain('discoverProcessModels');
+        expect(collect).not.toMatch(/SKILL\.md/);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.0.2",
+  "version": "9.1.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"