agentweaver 0.1.19 → 0.1.20

package/dist/interactive/auto-flow.js

@@ -0,0 +1,644 @@
+import { AUTO_FLOW_BLOCK_IDS, AUTO_FLOW_SLOT_NAMES, allowedAutoFlowBlocksForSlot, validateAutoFlowBlockInsertion, } from "../pipeline/auto-flow-config.js";
+import { getBuiltInAutoFlowBlockDefinition, listBuiltInAutoFlowBlockDefinitions } from "../pipeline/auto-flow-blocks.js";
+import { getBuiltInAutoFlowPreset } from "../pipeline/auto-flow-presets.js";
+import { AUTO_FLOW_SLOT_IDS, } from "../pipeline/auto-flow-types.js";
+const SLOT_TITLES = {
+    source: "Source",
+    normalize: "Normalize",
+    planning: "Planning",
+    designReview: "Design review",
+    implementation: "Implementation",
+    postImplementationChecks: "Post-implementation checks",
+    review: "Review",
+    final: "Final",
+};
+const OPTIONAL_SLOT_IDS = new Set(AUTO_FLOW_SLOT_NAMES);
+const FALLBACK_BLOCK_TITLES = {
+    "review.design-loop": "Design review loop",
+    "checks.go.linter": "Go linter loop",
+    "checks.go.tests": "Go tests loop",
+    "review.loop": "Review loop",
+};
+const FALLBACK_MAX_ITERATION_DEFAULTS = {
+    "review.design-loop": 3,
+    "checks.go.linter": 5,
+    "checks.go.tests": 5,
+    "review.loop": 5,
+};
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isOptionalSlot(slotId) {
+    return OPTIONAL_SLOT_IDS.has(slotId);
+}
+function isSavedBlockId(blockId) {
+    return AUTO_FLOW_BLOCK_IDS.includes(blockId);
+}
+function optionalSlotForBlock(blockId) {
+    for (const slotName of AUTO_FLOW_SLOT_NAMES) {
+        if (allowedAutoFlowBlocksForSlot(slotName).includes(blockId)) {
+            return slotName;
+        }
+    }
+    return null;
+}
+function validationDiagnostic(validation, fallback) {
+    return {
+        code: validation.message.startsWith("Unknown auto-flow block") ? "unknown-block" : "invalid-slot",
+        message: validation.message,
+        ...(validation.blockId ? { blockId: validation.blockId } : { blockId: fallback.blockId }),
+        ...(validation.slotName ? { slotId: validation.slotName } : fallback.slotId ? { slotId: fallback.slotId } : {}),
+    };
+}
+function resolveOptionalBlockSlot(blockId, slotId) {
+    if (slotId !== undefined) {
+        const validation = validateAutoFlowBlockInsertion(slotId, blockId);
+        if (!validation.ok || !validation.slotName || !validation.blockId) {
+            return {
+                diagnostics: [validationDiagnostic(validation, { slotId, blockId })],
+            };
+        }
+        return {
+            slotName: validation.slotName,
+            blockId: validation.blockId,
+        };
+    }
+    const slotName = optionalSlotForBlock(blockId);
+    if (!slotName || !isSavedBlockId(blockId)) {
+        return {
+            diagnostics: [{
+                    code: "unknown-block",
+                    message: `Unknown optional auto-flow block '${blockId}'.`,
+                    blockId,
+                }],
+        };
+    }
+    return {
+        slotName,
+        blockId,
+    };
+}
+function defaultOptionalBlocksForPreset(presetId, slotId) {
+    const preset = getBuiltInAutoFlowPreset(presetId);
+    return preset.blocks
+        .filter((placement) => placement.slot === slotId && isSavedBlockId(placement.blockId))
+        .map((placement) => ({
+        id: placement.blockId,
+        enabled: placement.defaultEnabled === false ? false : "auto",
+    }));
+}
+function coreBlockForSlot(presetId, slotId, diagnostics) {
+    const preset = getBuiltInAutoFlowPreset(presetId);
+    const placement = preset.blocks.find((candidate) => candidate.slot === slotId && candidate.locked);
+    if (!placement) {
+        return [];
+    }
+    const definition = getBuiltInAutoFlowBlockDefinition(placement.blockId);
+    const phaseId = phaseIdForBlock(slotId, placement.blockId);
+    const blockDiagnostics = diagnosticsFor(diagnostics, { slotId, blockId: placement.blockId });
+    const status = blockDiagnostics.some((diagnostic) => (diagnostic.code === "locked-block-disabled"
+        || diagnostic.code === "locked-block-removed"
+        || diagnostic.code === "missing-dependency"))
+        ? "blocked"
+        : blockDiagnostics.length > 0 ? "invalid" : "pending";
+    return [
+        {
+            blockId: placement.blockId,
+            title: definition?.title ?? placement.blockId,
+            slotId,
+            status,
+            reason: blockDiagnostics[0]?.message ?? "Locked core block.",
+            locked: true,
+            enabled: true,
+            actions: {
+                canEnable: false,
+                canDisable: false,
+                canRemove: false,
+                canEditParams: false,
+            },
+            params: [],
+            diagnostics: blockDiagnostics,
+            ...(phaseId ? { phaseId } : {}),
+        },
+    ];
+}
+function blockTitle(blockId) {
+    return getBuiltInAutoFlowBlockDefinition(blockId)?.title
+        ?? (isSavedBlockId(blockId) ? FALLBACK_BLOCK_TITLES[blockId] : undefined)
+        ?? blockId;
+}
+function parameterDefinitionForBlock(blockId) {
+    const definition = getBuiltInAutoFlowBlockDefinition(blockId);
+    const builtInParam = definition?.params?.maxIterations;
+    if (builtInParam) {
+        return builtInParam;
+    }
+    const fallbackDefault = FALLBACK_MAX_ITERATION_DEFAULTS[blockId];
+    if (fallbackDefault === undefined) {
+        return null;
+    }
+    return {
+        type: "integer",
+        min: 1,
+        max: 5,
+        default: fallbackDefault,
+        supportedExecutableValues: [fallbackDefault],
+    };
+}
+function blockParams(block) {
+    const definition = parameterDefinitionForBlock(block.id);
+    if (!definition) {
+        return [];
+    }
+    return [
+        {
+            name: "maxIterations",
+            label: "maxIterations",
+            type: "integer",
+            value: block.maxIterations ?? definition.default,
+            defaultValue: definition.default,
+            min: definition.min,
+            max: definition.max,
+        },
+    ];
+}
+function phaseIdForBlock(slotId, blockId) {
+    if (blockId === "source.jira")
+        return "source";
+    if (blockId === "normalize.task-source")
+        return "normalize";
+    if (blockId === "planning.plan")
+        return "plan";
+    if (blockId === "review.design-loop")
+        return "design_review_loop";
+    if (blockId === "implementation.default")
+        return "implement";
+    if (blockId === "review.loop")
+        return "review-loop";
+    if (blockId === "checks.go.linter")
+        return slotId === "final" ? "final_go_linter_loop" : "post_go_linter_loop";
+    if (blockId === "checks.go.tests")
+        return slotId === "final" ? "final_go_tests_loop" : "post_go_tests_loop";
+    return undefined;
+}
+function diagnosticsFor(diagnostics, input) {
+    return diagnostics.filter((diagnostic) => {
+        if (input.slotId && diagnostic.slotId !== undefined && diagnostic.slotId !== input.slotId) {
+            return false;
+        }
+        if (input.blockId && diagnostic.blockId !== input.blockId) {
+            return false;
+        }
+        if (input.paramName && diagnostic.paramName !== input.paramName) {
+            return false;
+        }
+        return true;
+    });
+}
+function validateEditorConfig(config) {
+    const diagnostics = [];
+    for (const slotName of AUTO_FLOW_SLOT_NAMES) {
+        const slot = config.slots?.[slotName];
+        if (!slot) {
+            continue;
+        }
+        const seen = new Set();
+        slot.blocks.forEach((block, index) => {
+            if (!allowedAutoFlowBlocksForSlot(slotName).includes(block.id)) {
+                diagnostics.push({
+                    code: "invalid-slot",
+                    message: `Auto-flow block '${block.id}' cannot be placed in slot '${slotName}'. Allowed blocks: ${allowedAutoFlowBlocksForSlot(slotName).join(", ")}.`,
+                    blockId: block.id,
+                    slotId: slotName,
+                    allowedSlots: [slotName],
+                });
+            }
+            if (seen.has(block.id)) {
+                diagnostics.push({
+                    code: "duplicate-block",
+                    message: `Auto-flow block '${block.id}' is placed more than once in slot '${slotName}'.`,
+                    blockId: block.id,
+                    slotId: slotName,
+                });
+            }
+            seen.add(block.id);
+            const paramDefinition = parameterDefinitionForBlock(block.id);
+            if (block.maxIterations !== undefined && !paramDefinition) {
+                diagnostics.push({
+                    code: "unknown-parameter",
+                    message: `Auto-flow block '${block.id}' does not support parameter 'maxIterations'.`,
+                    blockId: block.id,
+                    slotId: slotName,
+                    paramName: "maxIterations",
+                    value: block.maxIterations,
+                });
+            }
+            if (block.maxIterations !== undefined && paramDefinition && !Number.isInteger(block.maxIterations)) {
+                diagnostics.push({
+                    code: "invalid-parameter-type",
+                    message: `Auto-flow block '${block.id}' parameter 'maxIterations' must be an integer; received ${JSON.stringify(block.maxIterations)}.`,
+                    blockId: block.id,
+                    slotId: slotName,
+                    paramName: "maxIterations",
+                    value: block.maxIterations,
+                });
+            }
+            if (block.maxIterations !== undefined
+                && paramDefinition
+                && Number.isInteger(block.maxIterations)
+                && (block.maxIterations < paramDefinition.min || block.maxIterations > paramDefinition.max)) {
+                diagnostics.push({
+                    code: "parameter-out-of-range",
+                    message: `Auto-flow block '${block.id}' parameter 'maxIterations' must be between ${paramDefinition.min} and ${paramDefinition.max}; received ${block.maxIterations}.`,
+                    blockId: block.id,
+                    slotId: slotName,
+                    paramName: "maxIterations",
+                    value: block.maxIterations,
+                });
+            }
+            if (!isSavedBlockId(block.id)) {
+                diagnostics.push({
+                    code: "unknown-block",
+                    message: `Unknown auto-flow block '${block.id}' at slots.${slotName}.blocks[${index}].`,
+                    blockId: block.id,
+                    slotId: slotName,
+                });
+            }
+        });
+    }
+    return diagnostics;
+}
+function optionalBlocksForSlot(config, slotId) {
+    const defaultBlocks = defaultOptionalBlocksForPreset(config.basePreset, slotId);
+    const configuredBlocks = config.slots?.[slotId]?.blocks;
+    if (!configuredBlocks) {
+        return defaultBlocks.map((block) => ({
+            block,
+            statusReason: "Included by preset default.",
+            canRemove: true,
+        }));
+    }
+    const configuredIds = new Set(configuredBlocks.map((block) => block.id));
+    const blocks = configuredBlocks.map((block) => ({
+        block,
+        statusReason: "Configured in saved auto-flow config.",
+        canRemove: true,
+    }));
+    for (const defaultBlock of defaultBlocks) {
+        if (configuredIds.has(defaultBlock.id)) {
+            continue;
+        }
+        blocks.push({
+            block: {
+                ...defaultBlock,
+                enabled: false,
+            },
+            statusReason: "Skipped because the slot override omitted this preset default block.",
+            canRemove: false,
+        });
+    }
+    return blocks;
+}
+function blockStatus(block, diagnostics) {
+    if (diagnostics.length > 0) {
+        if (diagnostics.some((diagnostic) => (diagnostic.code === "locked-block-disabled"
+            || diagnostic.code === "locked-block-removed"
+            || diagnostic.code === "missing-dependency"))) {
+            return "blocked";
+        }
+        return "invalid";
+    }
+    if (block.enabled === false) {
+        return "disabled";
+    }
+    return "pending";
+}
+function blockReason(block, statusReason, diagnostics) {
+    if (diagnostics[0]) {
+        return diagnostics[0].message;
+    }
+    if (block.enabled === false) {
+        return "Optional block is disabled.";
+    }
+    return statusReason;
+}
+function optionalBlockView(slotId, block, statusReason, canRemove, diagnostics) {
+    const blockDiagnostics = diagnosticsFor(diagnostics, { slotId, blockId: block.id });
+    const params = blockParams(block);
+    const phaseId = phaseIdForBlock(slotId, block.id);
+    return {
+        blockId: block.id,
+        title: blockTitle(block.id),
+        slotId,
+        status: blockStatus(block, blockDiagnostics),
+        reason: blockReason(block, statusReason, blockDiagnostics),
+        locked: false,
+        enabled: block.enabled !== false,
+        actions: {
+            canEnable: block.enabled === false,
+            canDisable: block.enabled !== false,
+            canRemove,
+            canEditParams: params.length > 0,
+        },
+        params,
+        diagnostics: blockDiagnostics,
+        ...(phaseId ? { phaseId } : {}),
+    };
+}
+function slotStatus(blocks, diagnostics) {
+    if (diagnostics.length > 0 || blocks.some((block) => block.status === "invalid")) {
+        return "invalid";
+    }
+    if (blocks.length === 0) {
+        return "empty";
+    }
+    if (blocks.every((block) => block.status === "disabled")) {
+        return "disabled";
+    }
+    return "pending";
+}
+function slotReason(blocks, diagnostics) {
+    if (diagnostics[0]) {
+        return diagnostics[0].message;
+    }
+    if (blocks.length === 0) {
+        return "No blocks are configured for this optional slot.";
+    }
+    if (blocks.every((block) => block.status === "disabled")) {
+        return "All optional blocks in this slot are disabled.";
+    }
+    return "Slot is configured.";
+}
+function slotView(config, slotId, diagnostics) {
+    const slotDiagnostics = diagnosticsFor(diagnostics, { slotId });
+    const blocks = isOptionalSlot(slotId)
+        ? optionalBlocksForSlot(config, slotId).map(({ block, statusReason, canRemove }) => optionalBlockView(slotId, block, statusReason, canRemove, diagnostics))
+        : coreBlockForSlot(config.basePreset, slotId, diagnostics);
+    return {
+        slotId,
+        title: SLOT_TITLES[slotId],
+        status: slotStatus(blocks, slotDiagnostics),
+        reason: slotReason(blocks, slotDiagnostics),
+        blocks,
+        diagnostics: slotDiagnostics,
+    };
+}
+function sourceLabel(source) {
+    if (source.type === "preset") {
+        return `preset ${source.preset}`;
+    }
+    return `${source.type} ${source.configName}`;
+}
+export function defaultAutoFlowConfigForPreset(presetId, name = `preset-${presetId}`) {
+    return {
+        kind: "auto-flow-config",
+        version: 1,
+        name,
+        basePreset: presetId,
+    };
+}
+export function createPresetAutoFlowDefinition(presetId) {
+    return {
+        selection: { kind: "preset", preset: presetId },
+        basePreset: presetId,
+        config: defaultAutoFlowConfigForPreset(presetId),
+        source: {
+            type: "preset",
+            preset: presetId,
+        },
+    };
+}
+export function createConfigAutoFlowDefinition(input) {
+    return {
+        selection: { kind: "config", name: input.config.name },
+        basePreset: input.config.basePreset,
+        config: cloneJson(input.config),
+        source: input.source,
+    };
+}
+export function buildAutoFlowEditorViewModel(definition, options = {}) {
+    const config = options.config ?? definition.config;
+    const diagnostics = options.diagnostics ?? validateEditorConfig(config);
+    const slots = AUTO_FLOW_SLOT_IDS.map((slotId) => slotView(config, slotId, diagnostics));
+    const availableBlocks = [
+        ...listBuiltInAutoFlowBlockDefinitions().filter((block) => !block.locked).map((block) => ({
+            blockId: block.id,
+            title: block.title,
+            allowedSlots: [...block.allowedSlots],
+        })),
+        {
+            blockId: "checks.go.linter",
+            title: "Go linter loop",
+            allowedSlots: ["postImplementationChecks", "final"],
+        },
+        {
+            blockId: "checks.go.tests",
+            title: "Go tests loop",
+            allowedSlots: ["postImplementationChecks", "final"],
+        },
+    ];
+    const valid = diagnostics.length === 0;
+    const canReset = JSON.stringify(config) !== JSON.stringify(definition.config);
+    return {
+        selection: definition.selection,
+        basePreset: config.basePreset,
+        configName: config.name,
+        source: definition.source,
+        slots,
+        diagnostics: [...diagnostics],
+        availableBlocks,
+        status: {
+            valid,
+            canSave: valid,
+            canReset,
+            canRun: valid,
+            saveTarget: options.saveTarget ?? "project",
+            sourceLabel: sourceLabel(definition.source),
+            ...(options.lastMessage ? { lastMessage: options.lastMessage } : {}),
+        },
+    };
+}
+export function autoFlowSelectionForFlowId(flowId) {
+    if (flowId === "auto-simple") {
+        return { kind: "preset", preset: "simple" };
+    }
+    if (flowId === "auto-common") {
+        return { kind: "preset", preset: "standard" };
+    }
+    if (flowId.startsWith("auto-config:")) {
+        const name = flowId.slice("auto-config:".length);
+        if (/^[A-Za-z0-9._-]+$/.test(name)) {
+            return { kind: "config", name };
+        }
+    }
+    return null;
+}
+function ensureOptionalSlot(config, slotName) {
+    const nextSlots = {
+        ...(config.slots ?? {}),
+    };
+    const existing = nextSlots[slotName]?.blocks;
+    const blocks = existing
+        ? existing.map((block) => ({ ...block }))
+        : defaultOptionalBlocksForPreset(config.basePreset, slotName);
+    nextSlots[slotName] = { blocks };
+    config.slots = nextSlots;
+    return blocks;
+}
+export function setAutoFlowBlockEnabled(config, blockId, enabled, slotId) {
+    const next = cloneJson(config);
+    const coreDefinition = getBuiltInAutoFlowBlockDefinition(blockId);
+    if (coreDefinition?.locked) {
+        return {
+            config: next,
+            diagnostics: [{
+                    code: "locked-block-disabled",
+                    message: `Locked auto-flow block '${blockId}' cannot be disabled.`,
+                    blockId,
+                }],
+        };
+    }
+    const resolved = resolveOptionalBlockSlot(blockId, slotId);
+    if ("diagnostics" in resolved) {
+        return {
+            config: next,
+            diagnostics: resolved.diagnostics,
+        };
+    }
+    const blocks = ensureOptionalSlot(next, resolved.slotName);
+    const existing = blocks.find((block) => block.id === resolved.blockId);
+    if (existing) {
+        existing.enabled = enabled ? true : false;
+    }
+    else {
+        blocks.push({
+            id: resolved.blockId,
+            enabled: enabled ? true : false,
+        });
+    }
+    return {
+        config: next,
+        diagnostics: validateEditorConfig(next),
+    };
+}
+export function updateAutoFlowBlockParameter(config, blockId, paramName, value, slotId) {
+    const next = cloneJson(config);
+    if (paramName !== "maxIterations") {
+        return {
+            config: next,
+            diagnostics: [{
+                    code: "unknown-parameter",
+                    message: `Auto-flow block '${blockId}' does not support parameter '${paramName}'.`,
+                    blockId,
+                    paramName,
+                    value,
+                }],
+        };
+    }
+    const resolved = resolveOptionalBlockSlot(blockId, slotId);
+    if ("diagnostics" in resolved) {
+        return {
+            config: next,
+            diagnostics: resolved.diagnostics.map((diagnostic) => ({ ...diagnostic, paramName, value })),
+        };
+    }
+    const blocks = ensureOptionalSlot(next, resolved.slotName);
+    let block = blocks.find((candidate) => candidate.id === resolved.blockId);
+    if (!block) {
+        block = {
+            id: resolved.blockId,
+            enabled: true,
+        };
+        blocks.push(block);
+    }
+    block.maxIterations = value;
+    return {
+        config: next,
+        diagnostics: validateEditorConfig(next),
+    };
+}
+export function insertAutoFlowBlock(config, slotId, blockId) {
+    const next = cloneJson(config);
+    const validation = validateAutoFlowBlockInsertion(slotId, blockId);
+    if (!validation.ok) {
+        return {
+            config: next,
+            inserted: false,
+            diagnostics: [{
+                    code: validation.message.startsWith("Unknown auto-flow block") ? "unknown-block" : "invalid-slot",
+                    message: validation.message,
+                    ...(validation.blockId ? { blockId: validation.blockId } : { blockId }),
+                    ...(validation.slotName ? { slotId: validation.slotName } : { slotId }),
+                }],
+        };
+    }
+    if (!validation.slotName || !validation.blockId) {
+        return {
+            config: next,
+            inserted: false,
+            diagnostics: [{
+                    code: "invalid-slot",
+                    message: validation.message,
+                    blockId,
+                    slotId,
+                }],
+        };
+    }
+    const blocks = ensureOptionalSlot(next, validation.slotName);
+    if (!blocks.some((block) => block.id === validation.blockId)) {
+        blocks.push({
+            id: validation.blockId,
+            enabled: true,
+        });
+    }
+    return {
+        config: next,
+        inserted: true,
+        diagnostics: validateEditorConfig(next),
+    };
+}
+export function removeAutoFlowBlock(config, slotId, blockId) {
+    const next = cloneJson(config);
+    const coreDefinition = getBuiltInAutoFlowBlockDefinition(blockId);
+    if (coreDefinition?.locked) {
+        return {
+            config: next,
+            removed: false,
+            diagnostics: [{
+                    code: "locked-block-removed",
+                    message: `Locked auto-flow block '${blockId}' cannot be removed.`,
+                    blockId,
+                    slotId,
+                }],
+        };
+    }
+    const resolved = resolveOptionalBlockSlot(blockId, slotId);
+    if ("diagnostics" in resolved) {
+        return {
+            config: next,
+            removed: false,
+            diagnostics: resolved.diagnostics,
+        };
+    }
+    const blocks = ensureOptionalSlot(next, resolved.slotName);
+    const retained = blocks.filter((block) => block.id !== resolved.blockId);
+    const removed = retained.length !== blocks.length;
+    if (!removed) {
+        return {
+            config: next,
+            removed: false,
+            diagnostics: [{
+                    code: "unknown-block",
+                    message: `Auto-flow block '${resolved.blockId}' is not configured in slot '${resolved.slotName}'.`,
+                    blockId: resolved.blockId,
+                    slotId: resolved.slotName,
+                }],
+        };
+    }
+    blocks.splice(0, blocks.length, ...retained);
+    return {
+        config: next,
+        removed: true,
+        diagnostics: validateEditorConfig(next),
+    };
+}