agentic-workflow-manager 6.2.1 → 6.4.0

package/dist/src/core/tracks/ownership.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownershipPrefix = ownershipPrefix;
+exports.canonicalResource = canonicalResource;
+exports.assessDeclaredIndependence = assessDeclaredIndependence;
+exports.assessActualOwnership = assessActualOwnership;
+const path_1 = __importDefault(require("path"));
+const GLOBAL = [
+    { kind: 'lockfile', re: /(^|\/)(?:package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|Cargo\.lock|poetry\.lock)$/i },
+    { kind: 'manifest', re: /(^|\/)(?:package\.json|Cargo\.toml|pyproject\.toml)$/i },
+    { kind: 'migration', re: /(^|\/)(?:migrations?|schema)\//i },
+    { kind: 'snapshot', re: /(?:^|\/)(__snapshots__\/|[^/]+\.snap$)/i },
+    { kind: 'generated', re: /(^|\/)(?:dist|generated|coverage)\//i },
+];
+const canon = (p) => path_1.default.posix.normalize(p.replaceAll('\\', '/')).replace(/^\.\//, '');
+const key = (p) => canon(p).toLocaleLowerCase('en-US');
+const GLOB_CHARS = /[*?[\]{}]/;
+/**
+ * Formas soportadas: `dir/sub/file.ts`, `dir/`, `dir/*`, `dir/**`. Cualquier otro glob
+ * (intermedio, `?`, clases, llaves) se rechaza: un patrón que no sabemos expandir no puede
+ * usarse para AFIRMAR que dos tracks no se pisan.
+ */
+function ownershipPrefix(owner) {
+    const trimmed = canon(owner).replace(/\/(?:\*\*|\*)$/, '/');
+    if (GLOB_CHARS.test(trimmed))
+        throw new Error(`ownership no soporta este glob: ${owner}`);
+    return key(trimmed);
+}
+const covers = (owner, actual) => {
+    const o = ownershipPrefix(owner);
+    const a = key(actual);
+    return o.endsWith('/') ? a === o.slice(0, -1) || a.startsWith(o) : a === o;
+};
+/** Un patrón inexpandible cuenta como intersección: nunca habilita paralelismo por ignorancia. */
+const intersects = (left, right) => {
+    try {
+        return covers(left, right) || covers(right, left);
+    }
+    catch {
+        return true;
+    }
+};
+/** Simétrico del anterior: un patrón inexpandible nunca prueba propiedad. */
+const proves = (owner, actual) => {
+    try {
+        return covers(owner, actual);
+    }
+    catch {
+        return false;
+    }
+};
+function canonicalResource(raw) {
+    const match = raw.match(/^([a-z][a-z0-9-]*):(.+)$/i);
+    if (match === null || match[2].trim().length === 0)
+        throw new Error(`recurso debe usar <clase>:<valor>: ${raw}`);
+    // Case-fold el valor igual que `key()` hace con paths: sin esto, `db:Dev`
+    // y `db:dev` producen strings distintos y el Set.has() de
+    // assessDeclaredIndependence no detecta la colision (fail-open).
+    return `${match[1].toLowerCase()}:${match[2].trim().toLocaleLowerCase('en-US')}`;
+}
+function assessDeclaredIndependence(tracks) {
+    const reasons = new Set();
+    for (const t of tracks) {
+        for (const owner of t.ownership) {
+            try {
+                ownershipPrefix(owner);
+            }
+            catch {
+                reasons.add(`unsupported-glob:${canon(owner)}`);
+            }
+            const global = GLOBAL.find((g) => g.re.test(canon(owner)));
+            if (global !== undefined)
+                reasons.add(`global:${global.kind}:${canon(owner)}`);
+        }
+    }
+    for (let i = 0; i < tracks.length; i++)
+        for (let j = i + 1; j < tracks.length; j++) {
+            for (const left of tracks[i].ownership)
+                for (const right of tracks[j].ownership) {
+                    if (intersects(left, right))
+                        reasons.add(`path:${canon(right)}`);
+                }
+            const rightResources = new Set(tracks[j].sharedResources.map(canonicalResource));
+            for (const resource of tracks[i].sharedResources.map(canonicalResource)) {
+                if (rightResources.has(resource))
+                    reasons.add(`resource:${resource}`);
+            }
+        }
+    return { parallel: reasons.size === 0, reasons: [...reasons].sort() };
+}
+function assessActualOwnership(track, changes) {
+    const actual = changes.flatMap((c) => c.oldPath === undefined ? [c.path] : [c.oldPath, c.path]);
+    return {
+        outsideOwnership: actual.filter((p) => !track.ownership.some((o) => proves(o, p))).sort(),
+        globalClasses: actual.flatMap((p) => GLOBAL.filter((g) => g.re.test(canon(p))).map((g) => `${g.kind}:${canon(p)}`)).sort(),
+    };
+}

package/dist/src/core/tracks/plan-parser.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrackPlan = parseTrackPlan;
+const path_1 = __importDefault(require("path"));
+const taskHeading = /^### Task ([^:]+):/;
+const trackLine = /^\*\*Track:\*\*\s*(.*)$/;
+const fileLine = /^- (?:Create|Modify|Test|Delete):\s+`([^`]+)`/;
+const EXACT_MATCH_ERROR = 'membresía y filas de ## Tracks requieren coincidencia exacta';
+function jsonStrings(label, raw) {
+    if (raw === undefined)
+        throw new Error(`${label} es obligatorio para paralelismo`);
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${label} debe ser JSON string[]`);
+    }
+    if (!Array.isArray(value) || value.length === 0 || value.some((x) => typeof x !== 'string' || x.length === 0)) {
+        throw new Error(`${label} debe ser JSON string[] no vacío`);
+    }
+    return value;
+}
+function canonicalFile(raw) {
+    const withoutLines = raw.replace(/:\d+(?:-\d+)?$/, '');
+    const posix = withoutLines.replaceAll('\\', '/');
+    const normalized = path_1.default.posix.normalize(posix);
+    if (path_1.default.posix.isAbsolute(normalized) || normalized === '..' || normalized.startsWith('../')) {
+        throw new Error(`Files path fuera del repo: ${raw}`);
+    }
+    return normalized.replace(/^\.\//, '');
+}
+function parseTrackPlan(source, checkRef) {
+    const lines = source.replace(/\r\n/g, '\n').split('\n');
+    const hasMembership = lines.some((line) => trackLine.test(line));
+    const tracksHeading = lines.findIndex((line) => line.trim() === '## Tracks');
+    if (!hasMembership && tracksHeading < 0)
+        return { mode: 'serial', reason: 'no-tracks' };
+    if (!hasMembership || tracksHeading < 0)
+        throw new Error('Track membership y ## Tracks deben coexistir');
+    const argvRaw = lines.find((l) => l.startsWith('**Integration argv:**'))?.slice('**Integration argv:**'.length).trim();
+    const pathsRaw = lines.find((l) => l.startsWith('**Integration paths:**'))?.slice('**Integration paths:**'.length).trim();
+    const integration = { argv: jsonStrings('Integration argv', argvRaw), paths: jsonStrings('Integration paths', pathsRaw) };
+    const declared = new Map();
+    for (const line of lines.slice(tracksHeading + 1)) {
+        if (line.startsWith('## '))
+            break;
+        const cells = line.split('|').slice(1, -1).map((x) => x.trim());
+        if (cells.length !== 3 || cells[0] === 'Track' || /^[-:]+$/.test(cells[0]))
+            continue;
+        const [id, dependsRaw, resourcesRaw] = cells;
+        if (!id || id === '.' || id === '..' || id.startsWith('-') || id.includes('/') || id.includes('\\') || !checkRef(id)) {
+            throw new Error(`track id inválido: ${JSON.stringify(id)}`);
+        }
+        if (declared.has(id))
+            throw new Error(`track duplicado: ${id}`);
+        const resources = resourcesRaw === '[]' ? [] : resourcesRaw.length === 0 ? null : resourcesRaw.split(',').map((x) => x.trim());
+        const dependsOn = dependsRaw === 'none' ? [] : dependsRaw.split(',').map((x) => x.trim());
+        declared.set(id, { trackId: id, taskIds: [], ownership: [], dependsOn, sharedResources: resources ?? [] });
+        if (resources === null)
+            return { mode: 'serial', reason: `shared-resources-missing:${id}` };
+    }
+    let taskId = null;
+    let member = null;
+    let pendingFiles = [];
+    for (const line of lines) {
+        const heading = line.match(taskHeading);
+        if (heading !== null) {
+            if (taskId !== null && pendingFiles.length > 0 && member === null)
+                throw new Error(`task ${taskId} tiene Files pero no Track`);
+            taskId = heading[1].trim();
+            member = null;
+            pendingFiles = [];
+            continue;
+        }
+        const membership = line.match(trackLine);
+        if (membership !== null) {
+            if (taskId === null || member !== null)
+                throw new Error('cada task admite exactamente un Track');
+            member = membership[1].trim();
+            const track = declared.get(member);
+            if (track === undefined)
+                throw new Error(EXACT_MATCH_ERROR);
+            track.taskIds.push(taskId);
+            track.ownership.push(...pendingFiles);
+        }
+        const file = line.match(fileLine);
+        if (file !== null) {
+            const canonical = canonicalFile(file[1]);
+            if (member === null)
+                pendingFiles.push(canonical);
+            else
+                declared.get(member).ownership.push(canonical);
+        }
+    }
+    // La última task del documento no tiene un `### Task` siguiente que dispare el chequeo del loop.
+    if (taskId !== null && pendingFiles.length > 0 && member === null)
+        throw new Error(`task ${taskId} tiene Files pero no Track`);
+    const members = new Set([...declared.values()].flatMap((t) => t.taskIds.length > 0 ? [t.trackId] : []));
+    if (members.size !== declared.size)
+        throw new Error(EXACT_MATCH_ERROR);
+    if ([...declared.values()].some((t) => t.dependsOn.length > 0))
+        return { mode: 'serial', reason: 'track-dependency' };
+    return { mode: 'parallel-candidate', tracks: Object.fromEntries(declared), integration };
+}