agentweaver 0.1.19 → 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

@@ -323,6 +323,9 @@ function roleRank(role) {
 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) {
@@ -336,6 +339,10 @@ function compareCatalogItems(left, right) {
     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) {
@@ -348,11 +355,28 @@ export function groupArtifactCatalog(items) {
     }
     return Array.from(grouped.entries())
         .sort(([left], [right]) => left.localeCompare(right))
-        .map(([phaseId, phaseItems]) => ({
-        phaseId,
-        title: phaseId === UNCLASSIFIED_PHASE_ID ? "Unclassified" : toTitleCase(phaseId),
-        items: phaseItems.slice().sort(compareCatalogItems),
-    }));
+        .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();

package/dist/runtime/settings.js

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { agentweaverConfigDir } from "./env-loader.js";
+export const WEB_UI_AUTO_FLOW_HEIGHT_MIN = 120;
+export const WEB_UI_AUTO_FLOW_HEIGHT_MAX = 640;
+export const WEB_UI_WORKSPACE_SPLIT_MIN = 24;
+export const WEB_UI_WORKSPACE_SPLIT_MAX = 58;
+export const DEFAULT_AGENTWEAVER_WEB_UI_SETTINGS = {
+    theme: "light",
+    autoFlowHeight: null,
+    workspaceSplit: 36,
+    logAutoscroll: true,
+};
+export function agentweaverSettingsPath() {
+    return path.join(agentweaverConfigDir(), "settings.json");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampInteger(value, min, max, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, Math.round(numeric)));
+}
+function normalizeTheme(value, fallback) {
+    return value === "dark" || value === "light" ? value : fallback;
+}
+export function normalizeWebUiSettings(value) {
+    const raw = isRecord(value) ? value : {};
+    const defaults = DEFAULT_AGENTWEAVER_WEB_UI_SETTINGS;
+    const rawHeight = raw["autoFlowHeight"];
+    const autoFlowHeight = rawHeight === null
+        ? null
+        : Number.isFinite(Number(rawHeight))
+            ? clampInteger(rawHeight, WEB_UI_AUTO_FLOW_HEIGHT_MIN, WEB_UI_AUTO_FLOW_HEIGHT_MAX, defaults.autoFlowHeight ?? WEB_UI_AUTO_FLOW_HEIGHT_MAX)
+            : defaults.autoFlowHeight;
+    return {
+        theme: normalizeTheme(raw["theme"], defaults.theme),
+        autoFlowHeight,
+        workspaceSplit: clampInteger(raw["workspaceSplit"], WEB_UI_WORKSPACE_SPLIT_MIN, WEB_UI_WORKSPACE_SPLIT_MAX, defaults.workspaceSplit),
+        logAutoscroll: typeof raw["logAutoscroll"] === "boolean" ? raw["logAutoscroll"] : defaults.logAutoscroll,
+    };
+}
+export function normalizeWebUiSettingsPatch(patch) {
+    const normalized = {};
+    if (patch.theme !== undefined) {
+        normalized.theme = normalizeTheme(patch.theme, DEFAULT_AGENTWEAVER_WEB_UI_SETTINGS.theme);
+    }
+    if ("autoFlowHeight" in patch) {
+        normalized.autoFlowHeight = patch.autoFlowHeight === null || patch.autoFlowHeight === undefined
+            ? null
+            : clampInteger(patch.autoFlowHeight, WEB_UI_AUTO_FLOW_HEIGHT_MIN, WEB_UI_AUTO_FLOW_HEIGHT_MAX, WEB_UI_AUTO_FLOW_HEIGHT_MAX);
+    }
+    if (patch.workspaceSplit !== undefined) {
+        normalized.workspaceSplit = clampInteger(patch.workspaceSplit, WEB_UI_WORKSPACE_SPLIT_MIN, WEB_UI_WORKSPACE_SPLIT_MAX, DEFAULT_AGENTWEAVER_WEB_UI_SETTINGS.workspaceSplit);
+    }
+    if (patch.logAutoscroll !== undefined) {
+        normalized.logAutoscroll = Boolean(patch.logAutoscroll);
+    }
+    return normalized;
+}
+function readRawSettings() {
+    const filePath = agentweaverSettingsPath();
+    if (!existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeJsonAtomic(filePath, value) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    renameSync(tempPath, filePath);
+}
+export function loadAgentWeaverSettings() {
+    const raw = readRawSettings();
+    return {
+        kind: "agentweaver-settings",
+        version: 1,
+        webUi: normalizeWebUiSettings(raw["webUi"]),
+    };
+}
+export function saveAgentWeaverSettings(settings) {
+    const raw = readRawSettings();
+    const normalized = {
+        kind: "agentweaver-settings",
+        version: 1,
+        webUi: normalizeWebUiSettings(settings.webUi),
+    };
+    writeJsonAtomic(agentweaverSettingsPath(), {
+        ...raw,
+        ...normalized,
+    });
+    return normalized;
+}
+export function updateWebUiSettings(patch) {
+    const current = loadAgentWeaverSettings();
+    const next = saveAgentWeaverSettings({
+        ...current,
+        webUi: {
+            ...current.webUi,
+            ...normalizeWebUiSettingsPatch(patch),
+        },
+    });
+    return next.webUi;
+}

package/dist/scope.js

@@ -109,19 +109,24 @@ export function attachJiraContext(scope, jiraRef) {
         jiraTaskFile: jiraTaskFile(scope.scopeKey),
     };
 }
-export function buildJiraTaskInputForm() {
+export function buildJiraTaskInputForm(options = {}) {
+    const required = options.required ?? true;
     return {
         formId: "jira-task-input",
         title: "Jira Task",
-        description: "Provide a Jira issue key or browse URL for a task-driven flow.",
+        description: required
+            ? "Provide a Jira issue key or browse URL for a task-driven flow."
+            : "Provide a Jira issue key or browse URL, or leave it empty to paste the task description manually.",
         submitLabel: "Continue",
         fields: [
             {
                 id: "jira_ref",
                 type: "text",
                 label: "Jira issue key or browse URL",
-                help: "Example: DEMO-3288 or https://jira.example.com/browse/DEMO-3288",
-                required: true,
+                help: required
+                    ? "Example: DEMO-3288 or https://jira.example.com/browse/DEMO-3288"
+                    : "Leave empty to enter the task description manually in the next step.",
+                required,
             },
         ],
     };
@@ -134,3 +139,8 @@ export async function requestJiraContext(requestUserInput) {
     }
     return parseJiraContext(jiraRef);
 }
+export async function requestOptionalJiraContext(requestUserInput) {
+    const result = await requestUserInput(buildJiraTaskInputForm({ required: false }));
+    const jiraRef = String(result.values.jira_ref ?? "").trim();
+    return jiraRef ? parseJiraContext(jiraRef) : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentweaver",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "CLI orchestrator for Jira/Codex engineering workflows",
   "keywords": [
     "agent",

package/dist/pipeline/flow-specs/auto-common.json

@@ -1,179 +0,0 @@
-{
-  "kind": "auto-flow",
-  "version": 1,
-  "description": "End-to-end resumable pipeline without language-specific checks. Runs: Jira fetch → task source normalization → plan → design-review loop → implement → review loop. Planning gate requires design-review approval, or an explicit user decision to continue after the maximum revision attempts, before implementation.",
-  "phases": [
-    {
-      "id": "source",
-      "steps": [
-        {
-          "id": "fetch_jira_source",
-          "node": "flow-run",
-          "params": {
-            "fileName": { "const": "jira-fetch.json" },
-            "labelText": { "const": "Fetching Jira task source" },
-            "jiraApiUrl": { "ref": "params.jiraApiUrl" },
-            "taskKey": { "ref": "params.taskKey" }
-          }
-        }
-      ]
-    },
-    {
-      "id": "normalize",
-      "steps": [
-        {
-          "id": "run_normalize_source",
-          "node": "flow-run",
-          "params": {
-            "fileName": { "const": "normalize-task-source.json" },
-            "labelText": { "const": "Normalizing task source" },
-            "taskKey": { "ref": "params.taskKey" },
-            "iteration": { "ref": "params.taskContextIteration" },
-            "llmExecutor": { "ref": "params.llmExecutor" },
-            "llmModel": { "ref": "params.llmModel" },
-            "extraPrompt": { "ref": "params.extraPrompt" }
-          }
-        }
-      ]
-    },
-    {
-      "id": "plan",
-      "steps": [
-        {
-          "id": "run_plan_flow",
-          "node": "flow-run",
-          "params": {
-            "fileName": { "const": "plan.json" },
-            "labelText": { "const": "Running planning flow" },
-            "taskKey": { "ref": "params.taskKey" },
-            "taskContextIteration": { "ref": "params.taskContextIteration" },
-            "designIteration": { "ref": "params.designIteration" },
-            "planIteration": { "ref": "params.planIteration" },
-            "qaIteration": { "ref": "params.qaIteration" },
-            "llmExecutor": { "ref": "params.llmExecutor" },
-            "llmModel": { "ref": "params.llmModel" },
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "mdLang": { "ref": "params.mdLang" }
-          }
-        }
-      ]
-    },
-    {
-      "id": "design_review_loop",
-      "steps": [
-        {
-          "id": "run_design_review_loop",
-          "node": "flow-run",
-          "params": {
-            "fileName": { "const": "design-review-loop.json" },
-            "labelText": { "const": "Running design-review loop" },
-            "taskKey": { "ref": "params.taskKey" },
-            "baseIteration": { "ref": "params.designReviewBaseIteration" },
-            "workspaceDir": { "ref": "params.workspaceDir" },
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "llmExecutor": { "ref": "params.llmExecutor" },
-            "llmModel": { "ref": "params.llmModel" }
-          },
-          "stopFlowIf": {
-            "equals": [
-              { "ref": "steps.design_review_loop.run_design_review_loop.value.executionState.terminationOutcome" },
-              { "const": "stopped" }
-            ]
-          },
-          "stopFlowOutcome": "stopped"
-        }
-      ]
-    },
-    {
-      "id": "implement",
-      "steps": [
-        {
-          "id": "resolve_planning_bundle",
-          "node": "planning-bundle",
-          "params": {
-            "taskKey": { "ref": "params.taskKey" }
-          }
-        },
-        {
-          "id": "run_implement",
-          "node": "llm-prompt",
-          "routingGroup": "implementation",
-          "prompt": {
-            "templateRef": "implement",
-            "vars": {
-              "design_file": { "ref": "steps.implement.resolve_planning_bundle.value.designFile" },
-              "design_json_file": { "ref": "steps.implement.resolve_planning_bundle.value.designJsonFile" },
-              "plan_file": { "ref": "steps.implement.resolve_planning_bundle.value.planFile" },
-              "plan_json_file": { "ref": "steps.implement.resolve_planning_bundle.value.planJsonFile" },
-              "qa_file": { "ref": "steps.implement.resolve_planning_bundle.value.qaFile" },
-              "qa_json_file": { "ref": "steps.implement.resolve_planning_bundle.value.qaJsonFile" },
-              "project_guidance_file": { "const": "not provided" },
-              "project_guidance_json_file": { "const": "not provided" }
-            },
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "format": "task-prompt"
-          },
-          "params": {
-            "labelText": { "const": "Running implementation mode locally" },
-            "model": { "ref": "params.llmModel" },
-            "executor": { "ref": "params.llmExecutor" }
-          }
-        },
-        {
-          "id": "notify_implement_complete",
-          "node": "telegram-notify",
-          "params": {
-            "message": {
-              "template": "Implementation phase for {taskKey} complete.",
-              "vars": {
-                "taskKey": { "ref": "params.taskKey" }
-              }
-            }
-          }
-        }
-      ]
-    },
-    {
-      "id": "review-loop",
-      "steps": [
-        {
-          "id": "run_review_loop",
-          "node": "flow-run",
-          "stopFlowIf": {
-            "not": {
-              "equals": [
-                { "ref": "steps.review-loop.run_review_loop.value.executionState.terminationOutcome" },
-                { "const": "success" }
-              ]
-            }
-          },
-          "stopFlowOutcome": "stopped",
-          "params": {
-            "fileName": { "const": "review-loop.json" },
-            "labelText": { "const": "Running review-loop" },
-            "taskKey": { "ref": "params.taskKey" },
-            "baseIteration": { "ref": "params.baseIteration" },
-            "workspaceDir": { "ref": "params.workspaceDir" },
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "reviewFixPoints": { "ref": "params.reviewFixPoints" },
-            "reviewBlockingSeverities": { "ref": "params.reviewBlockingSeverities" },
-            "llmExecutor": { "ref": "params.llmExecutor" },
-            "llmModel": { "ref": "params.llmModel" }
-          }
-        },
-        {
-          "id": "notify_task_complete",
-          "node": "telegram-notify",
-          "params": {
-            "message": {
-              "template": "Task {taskKey} complete.",
-              "vars": {
-                "taskKey": { "ref": "params.taskKey" }
-              }
-            }
-          }
-        }
-      ]
-    }
-  ]
-}