agentic-workflow-manager 2.0.0

package/dist/src/core/miro.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeLayout = computeLayout;
+exports.syncToMiro = syncToMiro;
+// Layout constants — Miro enforces min card width of 256 and auto-calculates card height (~94dp+)
+const CARD_W = 260;
+const CARD_H = 100; // layout spacing only — not sent to API (Miro auto-calculates)
+const STORY_H = 150; // layout spacing only — generous to avoid overlap with auto-sized cards
+const COL_GAP = 20;
+const COL_W = CARD_W + COL_GAP; // 280
+const ROW_GAP = 15;
+const PADDING = 40;
+const TITLE_H = 50;
+const SWIMLANE_H = 40;
+const SWIMLANE_GAP = 30; // extra vertical space before each swimlane separator
+const ACTIVITY_GAP = 40; // horizontal gap between activity groups
+function sortReleases(releases) {
+    return [...releases].sort((a, b) => {
+        if (a === 'MVP' && b !== 'MVP')
+            return -1;
+        if (b === 'MVP' && a !== 'MVP')
+            return 1;
+        if (a === 'Backlog' && b !== 'Backlog')
+            return 1;
+        if (b === 'Backlog' && a !== 'Backlog')
+            return -1;
+        return a.localeCompare(b);
+    });
+}
+function computeLayout(storyMap) {
+    const { activities } = storyMap;
+    // Guard: return empty layout when there are no activities
+    if (activities.length === 0) {
+        return { frameWidth: 0, frameHeight: 0, items: [] };
+    }
+    // USM layout: each Task gets its own column. Activities span across their Tasks.
+    // Stories go below their corresponding Task column.
+    // Activity groups are separated by ACTIVITY_GAP for visual distinction.
+    // Collect all unique releases (ordered)
+    const releaseSet = new Set();
+    for (const activity of activities) {
+        for (const task of activity.tasks) {
+            for (const story of task.stories) {
+                releaseSet.add(story.release);
+            }
+        }
+    }
+    const releases = sortReleases([...releaseSet]);
+    // Max stories in any single task column per release (determines row height)
+    const maxStoriesPerRelease = new Map();
+    for (const release of releases) {
+        let max = 0;
+        for (const activity of activities) {
+            for (const task of activity.tasks) {
+                const count = task.stories.filter(s => s.release === release).length;
+                if (count > max)
+                    max = count;
+            }
+        }
+        maxStoriesPerRelease.set(release, max);
+    }
+    // Precompute activity group widths and X offsets
+    // Each group: numTasks * COL_W - COL_GAP, separated by ACTIVITY_GAP
+    const activityGroupWidths = activities.map(a => Math.max(1, a.tasks.length) * COL_W - COL_GAP);
+    const contentWidth = activityGroupWidths.reduce((sum, w) => sum + w, 0)
+        + (activities.length - 1) * ACTIVITY_GAP;
+    // Frame dimensions
+    const frameWidth = PADDING * 2 + contentWidth;
+    const releaseSectionH = releases.reduce((sum, r) => {
+        const maxStories = maxStoriesPerRelease.get(r) ?? 0;
+        return sum + SWIMLANE_GAP + SWIMLANE_H + maxStories * (STORY_H + ROW_GAP);
+    }, 0);
+    // Activity row + Task row + release sections
+    const frameHeight = PADDING + TITLE_H + CARD_H + ROW_GAP + CARD_H + ROW_GAP + releaseSectionH + PADDING;
+    // Frame top-left (frame centered at canvas origin)
+    const frameLeft = -frameWidth / 2;
+    const frameTop = -frameHeight / 2;
+    const items = [];
+    // Fixed Y positions
+    const activityY = frameTop + PADDING + TITLE_H + CARD_H / 2;
+    const taskY = activityY + CARD_H / 2 + ROW_GAP + CARD_H / 2;
+    // Build columns with ACTIVITY_GAP between groups
+    // Track the X offset for each task column (needed for stories later)
+    const taskColXPositions = []; // one per task across all activities
+    let groupLeftX = PADDING; // running X from frame left edge
+    for (let ai = 0; ai < activities.length; ai++) {
+        const activity = activities[ai];
+        const numTaskCols = Math.max(1, activity.tasks.length);
+        const groupWidth = activityGroupWidths[ai];
+        // Activity card — spans its task columns
+        const activityX = frameLeft + groupLeftX + groupWidth / 2;
+        items.push({
+            kind: 'activity',
+            title: activity.title,
+            x: activityX,
+            y: activityY,
+            width: groupWidth,
+            height: CARD_H,
+            color: '#ffdc4a',
+        });
+        // Task cards — one per column within this group
+        for (let j = 0; j < activity.tasks.length; j++) {
+            const colX = frameLeft + groupLeftX + j * COL_W + CARD_W / 2;
+            taskColXPositions.push(colX);
+            items.push({
+                kind: 'task',
+                title: activity.tasks[j].title,
+                x: colX,
+                y: taskY,
+                width: CARD_W,
+                height: CARD_H,
+                color: '#659df2',
+            });
+        }
+        // Activity with 0 tasks: placeholder column (no task card, but reserve X space)
+        if (activity.tasks.length === 0) {
+            taskColXPositions.push(frameLeft + groupLeftX + CARD_W / 2);
+        }
+        groupLeftX += groupWidth + ACTIVITY_GAP;
+    }
+    // Swimlanes and stories — each story goes below its Task column
+    let swimlaneTop = frameTop + PADDING + TITLE_H + CARD_H + ROW_GAP + CARD_H + ROW_GAP;
+    for (const release of releases) {
+        const maxStories = maxStoriesPerRelease.get(release) ?? 0;
+        // Extra gap before each swimlane
+        swimlaneTop += SWIMLANE_GAP;
+        const swimlaneCenterY = swimlaneTop + SWIMLANE_H / 2;
+        items.push({
+            kind: 'swimlane',
+            title: release,
+            x: 0,
+            y: swimlaneCenterY,
+            width: frameWidth,
+            height: SWIMLANE_H,
+        });
+        // Stories per task column (using precomputed X positions)
+        let colIdx = 0;
+        for (const activity of activities) {
+            if (activity.tasks.length === 0) {
+                colIdx++;
+                continue;
+            }
+            for (const task of activity.tasks) {
+                const colX = taskColXPositions[colIdx];
+                const releaseStories = task.stories.filter(s => s.release === release);
+                for (let k = 0; k < releaseStories.length; k++) {
+                    const storyY = swimlaneTop + SWIMLANE_H + k * (STORY_H + ROW_GAP) + STORY_H / 2;
+                    items.push({
+                        kind: 'story',
+                        title: releaseStories[k].title,
+                        x: colX,
+                        y: storyY,
+                        width: CARD_W,
+                        height: STORY_H,
+                        color: '#ffffff',
+                    });
+                }
+                colIdx++;
+            }
+        }
+        swimlaneTop += SWIMLANE_H + maxStories * (STORY_H + ROW_GAP);
+    }
+    return { frameWidth, frameHeight, items };
+}
+// ─── REST Client ─────────────────────────────────────────────────────────────
+const MIRO_BASE = 'https://api.miro.com/v2';
+async function miroRequest(config, method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30_000);
+    try {
+        const response = await fetch(`${MIRO_BASE}${path}`, {
+            method,
+            headers: {
+                'Authorization': `Bearer ${config.token}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            },
+            body: body ? JSON.stringify(body) : undefined,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Miro API ${method} ${path} → ${response.status}: ${text}`);
+        }
+        if (response.status === 204)
+            return null;
+        return response.json();
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function createFrame(config, title, width, height) {
+    // Position far from origin to avoid nesting inside any existing frame at (0,0)
+    const data = await miroRequest(config, 'POST', `/boards/${encodeURIComponent(config.boardId)}/frames`, {
+        data: { title, format: 'custom', type: 'freeform' },
+        style: { fillColor: '#f5f6f8' },
+        position: { x: 50000, y: 0, origin: 'center' },
+        geometry: { width, height },
+    });
+    if (!data?.id)
+        throw new Error('Miro API returned frame without id');
+    return data.id;
+}
+async function updateFrame(config, frameId, width, height) {
+    await miroRequest(config, 'PATCH', `/boards/${encodeURIComponent(config.boardId)}/frames/${frameId}`, {
+        geometry: { width, height },
+    });
+}
+async function createCard(config, frameId, item, offsetX, offsetY) {
+    const data = await miroRequest(config, 'POST', `/boards/${encodeURIComponent(config.boardId)}/cards`, {
+        data: { title: item.title },
+        style: { cardTheme: item.color },
+        position: { x: item.x + offsetX, y: item.y + offsetY, origin: 'center' },
+        geometry: { width: item.width }, // height is read-only, auto-calculated by Miro
+        parent: { id: frameId },
+    });
+    return data.id;
+}
+async function updateCard(config, cardId, item, offsetX, offsetY) {
+    await miroRequest(config, 'PATCH', `/boards/${encodeURIComponent(config.boardId)}/cards/${cardId}`, {
+        style: { cardTheme: item.color },
+        position: { x: item.x + offsetX, y: item.y + offsetY, origin: 'center' },
+        geometry: { width: item.width },
+    });
+}
+async function createText(config, frameId, item, offsetX, offsetY) {
+    const data = await miroRequest(config, 'POST', `/boards/${encodeURIComponent(config.boardId)}/texts`, {
+        data: { content: `<b>${item.title}</b>` },
+        style: { fillColor: '#e8e8e8', textAlign: 'left', fontSize: '14' },
+        position: { x: item.x + offsetX, y: item.y + offsetY, origin: 'center' },
+        geometry: { width: item.width }, // height not supported for text items
+        parent: { id: frameId },
+    });
+    return data.id;
+}
+async function deleteItem(config, itemId) {
+    await miroRequest(config, 'DELETE', `/boards/${encodeURIComponent(config.boardId)}/items/${itemId}`);
+}
+async function listFrameCards(config, frameId) {
+    const results = [];
+    let cursor;
+    do {
+        const url = `/boards/${encodeURIComponent(config.boardId)}/items?parent_item_id=${frameId}&type=card&limit=50${cursor ? `&cursor=${cursor}` : ''}`;
+        const data = await miroRequest(config, 'GET', url);
+        for (const item of data.data || []) {
+            results.push({ id: item.id, title: stripHtml(item.data?.title || '') });
+        }
+        cursor = data.cursor;
+    } while (cursor);
+    return results;
+}
+function stripHtml(html) {
+    return html.replace(/<[^>]+>/g, '').trim();
+}
+async function syncToMiro(config, storyMap, existingFrameId) {
+    const { frameWidth, frameHeight, items } = computeLayout(storyMap);
+    // Child items use coordinates relative to the frame's top-left corner.
+    // Layout engine computes coordinates centered at (0,0), so offset by half the frame dimensions.
+    const offsetX = frameWidth / 2;
+    const offsetY = frameHeight / 2;
+    let frameId = existingFrameId;
+    let created = 0;
+    let updated = 0;
+    let deleted = 0;
+    if (!frameId) {
+        // First sync: create frame + all items
+        frameId = await createFrame(config, `Story Map — ${storyMap.project}`, frameWidth, frameHeight);
+        for (const item of items) {
+            if (item.kind === 'swimlane') {
+                await createText(config, frameId, item, offsetX, offsetY);
+            }
+            else {
+                await createCard(config, frameId, item, offsetX, offsetY);
+            }
+            created++;
+        }
+    }
+    else {
+        // Subsequent sync: resize frame first so new positions don't exceed old boundaries,
+        // then diff and update cards.
+        await updateFrame(config, frameId, frameWidth, frameHeight);
+        const existingCards = await listFrameCards(config, frameId);
+        const existingByTitle = new Map(existingCards.map(c => [c.title, c.id]));
+        const newCardTitles = new Set(items.filter(i => i.kind !== 'swimlane').map(i => i.title));
+        // Delete cards no longer in the map
+        for (const existing of existingCards) {
+            if (!newCardTitles.has(existing.title)) {
+                await deleteItem(config, existing.id);
+                deleted++;
+            }
+        }
+        // Create or reposition cards from new layout
+        for (const item of items) {
+            // Note: swimlane text items are not diffed on re-sync.
+            // Renamed or removed releases require deleting and re-creating the frame manually.
+            // Full text-item diffing is a known limitation to address in a future iteration.
+            if (item.kind === 'swimlane')
+                continue;
+            const existingId = existingByTitle.get(item.title);
+            if (!existingId) {
+                await createCard(config, frameId, item, offsetX, offsetY);
+                created++;
+            }
+            else {
+                // Reposition and resize the existing card to match the current layout.
+                // This is necessary when the layout changes (new activities added, gaps adjusted, etc.)
+                await updateCard(config, existingId, item, offsetX, offsetY);
+                updated++;
+            }
+        }
+    }
+    return { frameId, created, updated, deleted };
+}

package/dist/src/core/profile-pins.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pinnedRepoDir = pinnedRepoDir;
+exports.verifyProjectPins = verifyProjectPins;
+// src/core/profile-pins.ts
+//
+// Gate de versión de `awm sync` — WS-3. Compara los pins del profile del
+// proyecto (.awm/profile.json → registries) contra la versión checkouteada
+// real de cada registry en la máquina.
+const fs_1 = __importDefault(require("fs"));
+const registries_1 = require("./registries");
+const versioning_1 = require("./versioning");
+/** Dir del clone de un registry pineable: ~/.awm/registries/<name>. */
+function pinnedRepoDir(name) {
+    return (0, registries_1.registryContentRoot)(name);
+}
+/** Verifica cada pin del proyecto contra la máquina. Lista vacía = todo en orden. */
+async function verifyProjectPins(pins) {
+    const failures = [];
+    for (const [name, requiredRaw] of Object.entries(pins)) {
+        const required = (0, versioning_1.normalizePin)(requiredRaw);
+        const dir = pinnedRepoDir(name);
+        if (!fs_1.default.existsSync(dir)) {
+            failures.push({ name, required, actual: null, reason: 'missing-registry' });
+            continue;
+        }
+        const actual = await (0, versioning_1.currentVersion)(dir);
+        if (actual !== required) {
+            failures.push({ name, required, actual, reason: 'mismatch' });
+        }
+    }
+    return failures;
+}

package/dist/src/core/profile.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+exports.readProfile = readProfile;
+exports.writeProfile = writeProfile;
+exports.ensureProfile = ensureProfile;
+exports.addExtension = addExtension;
+exports.ensureSkillsGitignored = ensureSkillsGitignored;
+exports.shouldRecordExtension = shouldRecordExtension;
+// src/core/profile.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../providers");
+/**
+ * Walks up from `startDir` looking for a project root marker
+ * (`.git/`, `package.json`, or `.awm/profile.json`). Returns the
+ * absolute (realpath) directory, or null if none is found.
+ */
+function findProjectRoot(startDir) {
+    let dir;
+    try {
+        dir = fs_1.default.realpathSync(path_1.default.resolve(startDir));
+    }
+    catch {
+        return null;
+    }
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(dir, '.git')) ||
+            fs_1.default.existsSync(path_1.default.join(dir, 'package.json')) ||
+            fs_1.default.existsSync(path_1.default.join(dir, '.awm', 'profile.json'))) {
+            return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function profilePath(root) {
+    return path_1.default.join(root, '.awm', 'profile.json');
+}
+const PIN_VERSION_RE = /^v?\d+\.\d+\.\d+$/;
+function readProfile(root) {
+    const file = profilePath(root);
+    if (!fs_1.default.existsSync(file))
+        return { extensions: [] };
+    let raw;
+    try {
+        raw = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        // JSON corrupto: comportamiento lenient histórico (perfil vacío)
+        return { extensions: [] };
+    }
+    const exts = Array.isArray(raw.extensions)
+        ? raw.extensions.filter((e) => typeof e === 'string')
+        : [];
+    const profile = { extensions: exts };
+    // El pin de proyecto es un contrato de versionado: malformado → error explícito
+    // (consistente con readRegistryManifest de WS-2), nunca silenciar.
+    if (raw.registries !== undefined) {
+        if (typeof raw.registries !== 'object' || raw.registries === null || Array.isArray(raw.registries)) {
+            throw new Error(`Invalid profile at ${file}: "registries" must be an object of name → version`);
+        }
+        const registries = {};
+        for (const [name, version] of Object.entries(raw.registries)) {
+            if (!name || name === '.' || name.includes('..') || /[/\\]/.test(name)) {
+                throw new Error(`Invalid profile at ${file}: registries key "${name}" is not a valid registry name`);
+            }
+            if (typeof version !== 'string' || !PIN_VERSION_RE.test(version)) {
+                throw new Error(`Invalid profile at ${file}: registries["${name}"] must be "X.Y.Z", got ${JSON.stringify(version)}`);
+            }
+            registries[name] = version.replace(/^v/, '');
+        }
+        profile.registries = registries;
+    }
+    return profile;
+}
+function writeProfile(root, profile) {
+    const dir = path_1.default.join(root, '.awm');
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(profilePath(root), JSON.stringify(profile, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Ensures `.awm/profile.json` exists, creating an empty `{ extensions: [] }`
+ * profile when absent. Idempotent: a present profile (with any extensions) is
+ * left untouched. Returns true only when it created the file.
+ *
+ * Without this, a project with no detectable extensions never gets a profile
+ * written (`addExtension` is the only other writer, and it only runs when there
+ * is something to add) — so `awm init` would leave the project flagged as
+ * uninitialized and self-referentially suggest re-running `awm init`.
+ */
+function ensureProfile(root) {
+    if (fs_1.default.existsSync(profilePath(root)))
+        return false;
+    writeProfile(root, { extensions: [] });
+    return true;
+}
+/** Adds a bundle name to the profile's extensions (deduped) and persists it. */
+function addExtension(root, name) {
+    const profile = readProfile(root);
+    if (!profile.extensions.includes(name))
+        profile.extensions.push(name);
+    writeProfile(root, profile);
+    return profile;
+}
+/**
+ * Ensures the project's .gitignore ignores the local artifact symlinks for
+ * all given agents (machine-specific; rebuilt by `awm sync`). Idempotent.
+ */
+function ensureSkillsGitignored(root, agents) {
+    const gi = path_1.default.join(root, '.gitignore');
+    const existing = fs_1.default.existsSync(gi) ? fs_1.default.readFileSync(gi, 'utf-8') : '';
+    const existingLines = existing.split(/\r?\n/).map((l) => l.trim());
+    const toIgnore = [];
+    for (const agent of agents) {
+        const provider = providers_1.PROVIDERS[agent];
+        for (const type of ['skill', 'workflow', 'agent']) {
+            const config = provider[type];
+            if (!config)
+                continue;
+            const entry = config.local.endsWith('/') ? config.local : `${config.local}/`;
+            if (!toIgnore.includes(entry))
+                toIgnore.push(entry);
+        }
+    }
+    const missing = toIgnore.filter((e) => !existingLines.some((l) => l === e || l === e.replace(/\/$/, '')));
+    if (missing.length === 0)
+        return;
+    const needsNewline = existing.length > 0 && !existing.endsWith('\n');
+    fs_1.default.appendFileSync(gi, `${needsNewline ? '\n' : ''}${missing.join('\n')}\n`);
+}
+/**
+ * A bundle is recorded as a project extension only when it is a `project`-scope
+ * bundle being installed locally. Baseline/ambient and global installs are not
+ * project extensions and stay out of `.awm/profile.json`.
+ */
+function shouldRecordExtension(bundleScope, effective) {
+    return bundleScope === 'project' && effective === 'local';
+}