agentweaver 0.1.18 → 0.1.20

package/dist/pipeline/nodes/manual-jira-task-input-node.js

@@ -0,0 +1,146 @@
+import { writeFileSync } from "node:fs";
+import { printSummary } from "../../tui.js";
+import { requestUserInputInTerminal, validateUserInputValues, } from "../../user-input.js";
+function summarizeDescription(description) {
+    return description
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0)
+        ?.slice(0, 140) || "Manual Jira task description";
+}
+function buildManualJiraPayload(taskKey, description) {
+    const summary = summarizeDescription(description);
+    return {
+        id: `manual-${taskKey}`,
+        key: taskKey,
+        self: null,
+        source: "manual-jira-fallback",
+        fields: {
+            summary,
+            description,
+            issuetype: {
+                name: "Manual task",
+            },
+            labels: ["manual-jira-fallback"],
+            attachment: [],
+            comment: {
+                comments: [],
+            },
+        },
+        manual_input: {
+            description,
+            captured_at: new Date().toISOString(),
+        },
+    };
+}
+export const manualJiraTaskInputNode = {
+    kind: "manual-jira-task-input",
+    version: 1,
+    async run(context, params) {
+        const form = {
+            formId: "manual-jira-task-input",
+            title: "Manual Jira Task",
+            description: "Paste the Jira task description when Jira access is unavailable.",
+            submitLabel: "Continue",
+            fields: [
+                {
+                    id: "task_description",
+                    type: "text",
+                    label: "Task description",
+                    help: "Paste the Jira task text here. This will be stored as the raw Jira task artifact for this flow.",
+                    required: true,
+                    multiline: true,
+                    rows: 10,
+                    placeholder: "Paste Jira task title, description, acceptance criteria, comments, and links here.",
+                },
+            ],
+        };
+        const requester = context.requestUserInput ?? requestUserInputInTerminal;
+        const result = await requester(form);
+        validateUserInputValues(form, result.values);
+        const description = String(result.values.task_description ?? "").trim();
+        writeFileSync(params.outputFile, `${JSON.stringify(buildManualJiraPayload(params.taskKey, description), null, 2)}\n`, "utf8");
+        if (params.attachmentsManifestFile) {
+            writeFileSync(params.attachmentsManifestFile, `${JSON.stringify({ source: "manual-jira-fallback", issueKey: params.taskKey, attachments: [] }, null, 2)}\n`, "utf8");
+        }
+        if (params.attachmentsContextFile) {
+            writeFileSync(params.attachmentsContextFile, "No Jira attachments were provided for the manual Jira fallback.\n", "utf8");
+        }
+        printSummary("Manual Jira Task", description);
+        const outputs = [
+            {
+                kind: "file",
+                path: params.outputFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-task.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            },
+        ];
+        if (params.attachmentsManifestFile) {
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsManifestFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-attachments.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            });
+        }
+        if (params.attachmentsContextFile) {
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsContextFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "jira-attachments-context.txt",
+                    payloadFamily: "plain-text",
+                    schemaId: "plain-text/v1",
+                    schemaVersion: 1,
+                },
+            });
+        }
+        return {
+            value: {
+                outputFile: params.outputFile,
+                ...(params.attachmentsManifestFile ? { attachmentsManifestFile: params.attachmentsManifestFile } : {}),
+                ...(params.attachmentsContextFile ? { attachmentsContextFile: params.attachmentsContextFile } : {}),
+                descriptionLength: description.length,
+            },
+            outputs,
+        };
+    },
+    checks(_context, params) {
+        const checks = [
+            {
+                kind: "require-file",
+                path: params.outputFile,
+                message: `Manual Jira task input did not produce ${params.outputFile}.`,
+            },
+        ];
+        if (params.attachmentsManifestFile) {
+            checks.push({
+                kind: "require-file",
+                path: params.attachmentsManifestFile,
+                message: `Manual Jira task input did not produce ${params.attachmentsManifestFile}.`,
+            });
+        }
+        if (params.attachmentsContextFile) {
+            checks.push({
+                kind: "require-file",
+                path: params.attachmentsContextFile,
+                message: `Manual Jira task input did not produce ${params.attachmentsContextFile}.`,
+            });
+        }
+        return checks;
+    },
+};

package/dist/pipeline/nodes/opencode-prompt-node.js

@@ -14,7 +14,14 @@ export const opencodePromptNode = {
         }, executor.defaultConfig);
         return {
             value,
-            outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+            outputs: (params.requiredArtifacts ?? []).map((path) => ({
+                kind: "artifact",
+                path,
+                required: true,
+                manifest: {
+                    publish: true,
+                },
+            })),
         };
     },
     checks(_context, params) {

package/dist/pipeline/nodes/plan-codex-node.js

@@ -17,7 +17,14 @@ export const planCodexNode = {
         const value = await executor.execute(toExecutorContext(context), input, executor.defaultConfig);
         return {
             value,
-            outputs: params.requiredArtifacts.map((path) => ({ kind: "artifact", path, required: true })),
+            outputs: params.requiredArtifacts.map((path) => ({
+                kind: "artifact",
+                path,
+                required: true,
+                manifest: {
+                    publish: true,
+                },
+            })),
         };
     },
     checks(_context, params) {

package/dist/pipeline/spec-loader.js

@@ -3,6 +3,8 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "../errors.js";
 import { agentweaverConfigDir } from "../runtime/env-loader.js";
+import { resolveBuiltInAutoFlowSpecByFileName } from "./auto-flow-resolver.js";
+import { VIRTUAL_BUILT_IN_AUTO_FLOW_FILE_NAMES } from "./auto-flow-presets.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const BUILT_IN_FLOW_SPECS_DIR = path.join(MODULE_DIR, "flow-specs");
 function parseFlowSpec(filePath) {
@@ -23,12 +25,14 @@ export function globalFlowSpecsDir() {
     return path.join(agentweaverConfigDir(), ".flows");
 }
 export function listBuiltInFlowSpecFiles() {
+    const files = new Set(VIRTUAL_BUILT_IN_AUTO_FLOW_FILE_NAMES);
     if (!existsSync(BUILT_IN_FLOW_SPECS_DIR)) {
-        return [];
+        return [...files].sort((left, right) => left.localeCompare(right));
+    }
+    for (const filePath of collectJsonFilesRecursively(BUILT_IN_FLOW_SPECS_DIR)) {
+        files.add(path.relative(BUILT_IN_FLOW_SPECS_DIR, filePath));
     }
-    return collectJsonFilesRecursively(BUILT_IN_FLOW_SPECS_DIR)
-        .map((filePath) => path.relative(BUILT_IN_FLOW_SPECS_DIR, filePath))
-        .sort((left, right) => left.localeCompare(right));
+    return [...files].sort((left, right) => left.localeCompare(right));
 }
 function collectJsonFilesRecursively(directory) {
     const entries = readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
@@ -60,6 +64,12 @@ export function listGlobalFlowSpecFiles() {
     return collectJsonFilesRecursively(directory);
 }
 export function loadFlowSpecSync(source) {
+    if (source.source === "built-in") {
+        const resolvedAutoFlowSpec = resolveBuiltInAutoFlowSpecByFileName(source.fileName);
+        if (resolvedAutoFlowSpec) {
+            return resolvedAutoFlowSpec;
+        }
+    }
     return parseFlowSpec(source.source === "built-in" ? resolveBuiltInFlowSpecPath(source.fileName) : source.filePath);
 }
 export function loadBuiltInFlowSpecSync(fileName) {

package/dist/runtime/artifact-catalog.js

@@ -0,0 +1,403 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../artifact-manifest.js";
+import { artifactIndexFile, artifactManifestSidecarPath, scopeArtifactsDir, scopeWorkspaceDir, } from "../artifacts.js";
+const UNCLASSIFIED_PHASE_ID = "unclassified";
+const ROLE_MAPPINGS = [
+    { prefix: "bug-fix-design", role: "design", title: "Bug Fix Design" },
+    { prefix: "bug-fix-plan", role: "plan", title: "Bug Fix Plan" },
+    { prefix: "bug-analyze", role: "analysis", title: "Bug Analysis" },
+    { prefix: "task-context", role: "context", title: "Task Context" },
+    { prefix: "gitlab-diff", role: "diff", title: "GitLab Diff" },
+    { prefix: "jira-description", role: "context", title: "Jira Description" },
+    { prefix: "design", role: "design", title: "Design" },
+    { prefix: "plan", role: "plan", title: "Plan" },
+    { prefix: "review", role: "review", title: "Review" },
+    { prefix: "qa", role: "qa", title: "QA Plan" },
+    { prefix: "task", role: "summary", title: "Task Summary" },
+];
+const ROLE_ORDER = new Map([
+    ["context", 10],
+    ["analysis", 20],
+    ["design", 30],
+    ["plan", 40],
+    ["qa", 50],
+    ["review", 60],
+    ["diff", 70],
+    ["summary", 80],
+    ["artifact", 90],
+]);
+const BINARY_EXTENSIONS = new Set([
+    ".avif",
+    ".bin",
+    ".bmp",
+    ".gif",
+    ".gz",
+    ".ico",
+    ".jpeg",
+    ".jpg",
+    ".pdf",
+    ".png",
+    ".tar",
+    ".tgz",
+    ".webp",
+    ".zip",
+]);
+function normalizePathSeparators(value) {
+    return value.replace(/\\/g, "/");
+}
+function normalizedAbsolutePath(filePath) {
+    return path.normalize(path.resolve(filePath));
+}
+function isInsideDirectory(parent, candidate) {
+    const relative = path.relative(parent, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function scopeRelativePath(scopeKey, payloadPath) {
+    const workspaceDir = normalizedAbsolutePath(scopeWorkspaceDir(scopeKey));
+    const normalizedPayloadPath = normalizedAbsolutePath(payloadPath);
+    if (!isInsideDirectory(workspaceDir, normalizedPayloadPath)) {
+        return normalizePathSeparators(path.basename(normalizedPayloadPath));
+    }
+    const relativePath = path.relative(workspaceDir, normalizedPayloadPath);
+    return normalizePathSeparators(relativePath || path.basename(normalizedPayloadPath));
+}
+function fileMetadata(filePath, fallbackIso) {
+    try {
+        const stats = statSync(filePath);
+        return {
+            sizeBytes: stats.size,
+            updatedAt: stats.mtime.toISOString(),
+        };
+    }
+    catch {
+        return {
+            sizeBytes: 0,
+            updatedAt: fallbackIso,
+        };
+    }
+}
+function cleanBaseName(value) {
+    const extension = path.extname(value);
+    return extension ? value.slice(0, -extension.length) : value;
+}
+function stripScopeAndVersionSuffix(value, scopeKey) {
+    const escapedScope = scopeKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value
+        .replace(new RegExp(`-${escapedScope}-iter-\\d+$`), "")
+        .replace(new RegExp(`-${escapedScope}-\\d+$`), "")
+        .replace(new RegExp(`-${escapedScope}$`), "")
+        .replace(/-\d+$/, "");
+}
+function toTitleCase(value) {
+    return value
+        .replace(/[/_.-]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function mappingForKey(logicalKeyOrPath) {
+    const normalized = logicalKeyOrPath.replace(/^\.artifacts\//, "").replace(/^artifacts\//, "");
+    const fileStem = cleanBaseName(path.posix.basename(normalized));
+    const candidates = [normalized, fileStem];
+    return ROLE_MAPPINGS.find((mapping) => (candidates.some((candidate) => candidate === mapping.prefix || candidate.startsWith(`${mapping.prefix}-`)))) ?? null;
+}
+export function inferArtifactRole(logicalKey, relativePath) {
+    const mapping = mappingForKey(logicalKey ?? relativePath);
+    return mapping?.role ?? "artifact";
+}
+export function inferArtifactTitle(scopeKey, logicalKey, relativePath) {
+    const source = logicalKey ?? relativePath;
+    const mapping = mappingForKey(source);
+    if (mapping) {
+        return mapping.title;
+    }
+    const stem = stripScopeAndVersionSuffix(cleanBaseName(path.posix.basename(normalizePathSeparators(source))), scopeKey);
+    return toTitleCase(stem) || "Artifact";
+}
+function kindFromPayloadFamily(payloadFamily) {
+    if (payloadFamily === "markdown") {
+        return "markdown";
+    }
+    if (payloadFamily === "structured-json" || payloadFamily === "helper-json") {
+        return "json";
+    }
+    if (payloadFamily === "plain-text") {
+        return "text";
+    }
+    if (payloadFamily === "opaque-file") {
+        return "binary";
+    }
+    return null;
+}
+function kindFromSchemaId(schemaId) {
+    if (!schemaId) {
+        return null;
+    }
+    const normalized = schemaId.toLowerCase();
+    if (normalized.includes("markdown")) {
+        return "markdown";
+    }
+    if (normalized.includes("diff") || normalized.includes("patch")) {
+        return "diff";
+    }
+    if (normalized.includes("text") || normalized.includes("log")) {
+        return "text";
+    }
+    if (normalized.endsWith("/v1") || normalized.includes("json")) {
+        return "json";
+    }
+    return null;
+}
+function kindFromExtension(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === ".md" || extension === ".markdown") {
+        return "markdown";
+    }
+    if (extension === ".json") {
+        return "json";
+    }
+    if (extension === ".txt" || extension === ".log") {
+        return "text";
+    }
+    if (extension === ".diff" || extension === ".patch") {
+        return "diff";
+    }
+    if (BINARY_EXTENSIONS.has(extension)) {
+        return "binary";
+    }
+    return "unknown";
+}
+export function inferArtifactRenderKind(input) {
+    return kindFromPayloadFamily(input.payloadFamily)
+        ?? kindFromSchemaId(input.schemaId)
+        ?? kindFromExtension(input.filePath);
+}
+function projectManifestRecord(scopeKey, record) {
+    const manifest = record.manifest;
+    const metadata = fileMetadata(manifest.payload_path, manifest.created_at);
+    const relativePath = scopeRelativePath(scopeKey, manifest.payload_path);
+    const logicalKey = record.logical_key || manifest.logical_key;
+    return {
+        id: record.artifact_id,
+        scopeKey,
+        runId: manifest.run_id,
+        logicalKey,
+        title: inferArtifactTitle(scopeKey, logicalKey, relativePath),
+        relativePath,
+        kind: inferArtifactRenderKind({
+            payloadFamily: manifest.payload_family,
+            schemaId: record.schema_id || manifest.schema_id,
+            filePath: manifest.payload_path,
+        }),
+        role: inferArtifactRole(logicalKey, relativePath),
+        phaseId: manifest.phase_id || null,
+        stepId: manifest.step_id || null,
+        schemaId: record.schema_id || manifest.schema_id || null,
+        sizeBytes: metadata.sizeBytes,
+        updatedAt: metadata.updatedAt,
+        isLatest: record.is_latest,
+        source: "manifest",
+    };
+}
+function isExcludedDirectory(name) {
+    return name === "manifest-history" || name === "restart-archives";
+}
+function isRegistryTempFile(filePath) {
+    const baseName = path.basename(filePath);
+    return /\.tmp-[^/\\]+$/.test(baseName)
+        || baseName.endsWith(".tmp")
+        || baseName.endsWith(".temp")
+        || baseName.endsWith(".swp")
+        || baseName.endsWith("~");
+}
+function isInternalIndexFile(filePath) {
+    const baseName = path.basename(filePath);
+    return baseName === "artifact-index.json"
+        || baseName === "artifact-registry-index.json"
+        || baseName === "manifest-index.json"
+        || baseName === "internal-index.json"
+        || baseName === ".index.json";
+}
+function isExcludedCatalogPath(scopeKey, filePath) {
+    const normalizedPath = normalizedAbsolutePath(filePath);
+    const workspaceDir = normalizedAbsolutePath(scopeWorkspaceDir(scopeKey));
+    if (!isInsideDirectory(workspaceDir, normalizedPath)) {
+        return true;
+    }
+    const relativePath = normalizePathSeparators(path.relative(workspaceDir, normalizedPath));
+    const segments = relativePath.split("/");
+    if (segments.some((segment) => segment === "manifest-history" || segment === "restart-archives")) {
+        return true;
+    }
+    if (normalizedPath === normalizedAbsolutePath(artifactIndexFile(scopeKey))) {
+        return true;
+    }
+    if (normalizedPath.endsWith(".manifest.json") || normalizedPath === normalizedAbsolutePath(artifactManifestSidecarPath(normalizedPath))) {
+        return true;
+    }
+    if (isInternalIndexFile(normalizedPath) || isRegistryTempFile(normalizedPath)) {
+        return true;
+    }
+    return path.basename(normalizedPath) === ".DS_Store";
+}
+function scanRoot(scopeKey, rootDir, seenDirectories) {
+    const normalizedRoot = normalizedAbsolutePath(rootDir);
+    const workspaceDir = normalizedAbsolutePath(scopeWorkspaceDir(scopeKey));
+    if (!existsSync(normalizedRoot) || !isInsideDirectory(workspaceDir, normalizedRoot)) {
+        return [];
+    }
+    const files = [];
+    const queue = [normalizedRoot];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const normalizedCurrent = normalizedAbsolutePath(current);
+        if (seenDirectories.has(normalizedCurrent)) {
+            continue;
+        }
+        seenDirectories.add(normalizedCurrent);
+        let entries;
+        try {
+            entries = readdirSync(normalizedCurrent, { withFileTypes: true })
+                .sort((left, right) => left.name.localeCompare(right.name));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(normalizedCurrent, entry.name);
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (!isExcludedDirectory(entry.name)) {
+                    queue.push(fullPath);
+                }
+                continue;
+            }
+            if (entry.isFile() && !isExcludedCatalogPath(scopeKey, fullPath)) {
+                files.push(normalizedAbsolutePath(fullPath));
+            }
+        }
+    }
+    return files;
+}
+function scanScopeFiles(scopeKey) {
+    const seenDirectories = new Set();
+    const files = [
+        ...scanRoot(scopeKey, scopeWorkspaceDir(scopeKey), seenDirectories),
+        ...scanRoot(scopeKey, scopeArtifactsDir(scopeKey), seenDirectories),
+    ];
+    return [...new Set(files)].sort((left, right) => scopeRelativePath(scopeKey, left).localeCompare(scopeRelativePath(scopeKey, right)));
+}
+function projectScannedFile(scopeKey, filePath) {
+    const relativePath = scopeRelativePath(scopeKey, filePath);
+    const logicalKey = buildLogicalKeyForPayload(scopeKey, filePath);
+    const metadata = fileMetadata(filePath, new Date(0).toISOString());
+    return {
+        id: `scanner:${scopeKey}:${relativePath}`,
+        scopeKey,
+        runId: null,
+        logicalKey,
+        title: inferArtifactTitle(scopeKey, logicalKey, relativePath),
+        relativePath,
+        kind: inferArtifactRenderKind({ filePath }),
+        role: inferArtifactRole(logicalKey, relativePath),
+        phaseId: null,
+        stepId: null,
+        schemaId: null,
+        sizeBytes: metadata.sizeBytes,
+        updatedAt: metadata.updatedAt,
+        isLatest: true,
+        source: "scanner",
+    };
+}
+function roleRank(role) {
+    return ROLE_ORDER.get(role) ?? 100;
+}
+function phaseSortKey(phaseId) {
+    return phaseId ?? UNCLASSIFIED_PHASE_ID;
+}
+function typeGroupKey(item) {
+    return `${item.role}:${item.title}`;
+}
+function compareCatalogItems(left, right) {
+    const phaseComparison = phaseSortKey(left.phaseId).localeCompare(phaseSortKey(right.phaseId));
+    if (phaseComparison !== 0) {
+        return phaseComparison;
+    }
+    const roleComparison = roleRank(left.role) - roleRank(right.role);
+    if (roleComparison !== 0) {
+        return roleComparison;
+    }
+    const titleComparison = left.title.localeCompare(right.title);
+    if (titleComparison !== 0) {
+        return titleComparison;
+    }
+    const updatedComparison = right.updatedAt.localeCompare(left.updatedAt);
+    if (updatedComparison !== 0) {
+        return updatedComparison;
+    }
+    return left.relativePath.localeCompare(right.relativePath);
+}
+export function groupArtifactCatalog(items) {
+    const grouped = new Map();
+    for (const item of items) {
+        const phaseId = item.phaseId ?? UNCLASSIFIED_PHASE_ID;
+        const phaseItems = grouped.get(phaseId) ?? [];
+        phaseItems.push(item);
+        grouped.set(phaseId, phaseItems);
+    }
+    return Array.from(grouped.entries())
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([phaseId, phaseItems]) => {
+        const sortedPhaseItems = phaseItems.slice().sort(compareCatalogItems);
+        const typeGroups = new Map();
+        for (const item of sortedPhaseItems) {
+            const key = typeGroupKey(item);
+            const groupItems = typeGroups.get(key) ?? [];
+            groupItems.push(item);
+            typeGroups.set(key, groupItems);
+        }
+        const nestedGroups = Array.from(typeGroups.entries())
+            .map(([key, groupItems]) => ({
+            phaseId: `${phaseId}:${key}`,
+            title: groupItems[0]?.title ?? "Artifacts",
+            items: groupItems.slice().sort(compareCatalogItems),
+        }));
+        return {
+            phaseId,
+            title: phaseId === UNCLASSIFIED_PHASE_ID ? "Unclassified" : toTitleCase(phaseId),
+            items: sortedPhaseItems,
+            ...(nestedGroups.length > 1 || nestedGroups.some((group) => group.items.length > 1) ? { groups: nestedGroups } : {}),
+        };
+    });
+}
+export function listArtifactCatalog(input) {
+    const seenPayloadPaths = new Set();
+    const items = [];
+    for (const record of input.artifactRegistry.listScopeArtifacts(input.scopeKey)) {
+        const payloadPath = normalizedAbsolutePath(record.manifest.payload_path);
+        seenPayloadPaths.add(payloadPath);
+        items.push(projectManifestRecord(input.scopeKey, record));
+    }
+    for (const filePath of scanScopeFiles(input.scopeKey)) {
+        const normalizedPath = normalizedAbsolutePath(filePath);
+        if (seenPayloadPaths.has(normalizedPath)) {
+            continue;
+        }
+        seenPayloadPaths.add(normalizedPath);
+        items.push(projectScannedFile(input.scopeKey, normalizedPath));
+    }
+    const sortedItems = items.slice().sort(compareCatalogItems);
+    return {
+        scopeKey: input.scopeKey,
+        items: sortedItems,
+        groups: groupArtifactCatalog(sortedItems),
+    };
+}