agentweaver 0.1.19 → 0.1.20

package/README.md

@@ -56,7 +56,7 @@ In practice, this means you can treat an agent workflow like an engineered syste
 
 - `resume` only resumes a genuinely interrupted run and uses the saved execution state without rebuilding already completed steps
 - `continue` is intended for completed iterative cycles and starts the next iteration from the latest valid artifacts without deleting historical artifacts
-- `restart` is treated as a new run: the current active attempt is archived under `.agentweaver/scopes/<scope>/.artifacts/restart-archives/attempt-XXXX`, then a new active attempt is created
+- `restart` is treated as a new run. For end-to-end attempt flows, the current active attempt is archived under `.agentweaver/scopes/<scope>/.artifacts/restart-archives/attempt-XXXX` before the new attempt starts; for independent single-purpose flows, restart only resets that flow's saved state and keeps existing scope artifacts available.
 - For ambiguous launches, the operator must choose the action explicitly: by confirmation in interactive mode, or with `--resume`, `--continue`, or `--restart` in non-interactive mode
 - This contract applies to `auto-common`, `auto-simple`, `auto-golang`, `instant-task`, `review-loop`, `run-go-linter-loop`, and `run-go-tests-loop`
 
@@ -92,7 +92,7 @@ The full flow-spec reference now lives in [docs/declarative-workflows.md](docs/d
 
 User-invokable built-in commands currently map to these flow specs:
 
-- `plan` — fetches Jira task with attachments, generates clarifying questions for the developer, collects answers, and produces design, implementation plan, and QA plan as structured JSON and markdown artifacts
+- `plan` — uses a normalized task source from Jira or manual input, generates clarifying questions for the developer, collects answers, and produces design, implementation plan, and QA plan as structured JSON and markdown artifacts
 - `design-review` — performs a structured critique of the latest planning artifacts and writes a dedicated `design-review/v1` artifact; `approved_with_warnings` is treated as ready to proceed and may still produce `ready-to-merge.md`
 - `task-describe` — generates a brief task description from a Jira issue or from manual input; when Jira is provided, fetches the issue and summarizes it; otherwise accepts free-form text and analyzes the codebase to produce a richer description
 - `implement` — runs LLM-backed implementation based on previously approved design and plan artifacts; executes code changes locally in the project working directory
@@ -144,11 +144,11 @@ By default, AgentWeaver tries to open the browser after the server starts succes
 
 The Web UI serves the operator console from the same local process, including `/`, `/static/app.js`, and `/static/styles.css`. Live browser interaction uses WebSocket on `/__agentweaver/ws`. Bounded checks can use `GET /__agentweaver/health`, and shutdown is available through `POST /__agentweaver/exit` or `SIGINT`/`SIGTERM`.
 
-Web UI state is process-local: it exists only while the AgentWeaver process is running and is not shared with other AgentWeaver processes. The Web UI is intended to match the interactive operator workflow for flow selection, launch confirmation, routing and user-input forms, progress and logs, and interrupt handling.
+Web UI session state is process-local: active flow selection, confirmations, forms, progress, and logs exist only while the AgentWeaver process is running and are not shared with other AgentWeaver processes. Visual preferences such as theme, panel sizes, and log auto-scroll are stored in the global AgentWeaver settings file at `~/.agentweaver/settings.json`, so they survive host and port changes.
 
 ### Artifact Explorer
 
-After a Web UI workflow completes, and also after a failed run when artifacts were written before failure, the Web UI offers the Artifact Explorer. It reads artifacts from the active AgentWeaver scope only, optionally filtered to the run id published by the completed workflow. The browser requests artifact content through safe artifact identifiers resolved by the active catalog and registry; it does not accept arbitrary filesystem paths.
+After a Web UI workflow completes, and also after a failed run when artifacts were written before failure, the Web UI offers the Artifact Explorer. It reads markdown artifacts from the active AgentWeaver scope, including artifacts from earlier runs in that scope; the latest workflow run is used only to choose the initial preview when possible. The browser requests artifact content through safe artifact identifiers resolved by the active catalog and registry; it does not accept arbitrary filesystem paths.
 
 The MVP explorer previews Markdown, JSON, plain text, and diff artifacts. Diffs are rendered as text. Binary and unknown artifacts are listed with metadata and safe raw/download actions, but their inline preview is a placeholder. Large previews are bounded and marked as truncated with loaded byte and total size metadata; raw and download links can still serve the full artifact bytes with no-store cache headers and safe content types.
 
@@ -300,6 +300,10 @@ agentweaver gitlab-review
 agentweaver mr-description DEMO-1234
 agentweaver run-go-tests-loop DEMO-1234
 agentweaver run-go-linter-loop DEMO-1234
+agentweaver auto DEMO-1234
+agentweaver auto --preset simple DEMO-1234
+agentweaver auto --preset standard --dry-run-flow DEMO-1234
+agentweaver auto --config backend-standard --dry-run-flow DEMO-1234
 agentweaver auto-golang DEMO-1234
 agentweaver auto-common DEMO-1234
 agentweaver auto-simple DEMO-1234
@@ -315,6 +319,7 @@ node dist/index.js plan DEMO-1234
 node dist/index.js design-review DEMO-1234
 node dist/index.js implement DEMO-1234
 node dist/index.js review DEMO-1234
+node dist/index.js auto --preset standard --dry-run-flow DEMO-1234
 node dist/index.js auto-golang DEMO-1234
 node dist/index.js auto-common DEMO-1234
 ```
@@ -337,12 +342,17 @@ agentweaver doctor --json
 Notes:
 
 - `--dry` fetches required context but prints launch commands instead of running Codex/OpenCode steps
+- `--dry-run-flow` applies only to `agentweaver auto`; it validates and previews the resolved flow without running workflow steps or writing resolver artifacts
+- `--preset <simple|standard>` applies only to `agentweaver auto`; raw `agentweaver auto` defaults to `--preset standard`
+- `--config <name>` applies only to `agentweaver auto`; it loads a saved YAML config by name
 - `--verbose` streams child process stdout/stderr in direct CLI mode
 - `--prompt <text>` appends extra instructions to the prompt
 - `--scope <name>` is supported by scope-flexible flows such as `implement`, `review`, `review-fix`, `review-loop`, `run-go-tests-loop`, `run-go-linter-loop`, `gitlab-review`, and `gitlab-diff-review`
 - `--md-lang <en|ru>` applies only to generated workflow markdown artifacts, not repository source files or committed documentation
 - `--force` only affects interactive mode: it skips loading cached summary-pane content on startup so Jira-backed flows that regenerate summary artifacts can repopulate it during the run
-- Jira-backed flows ask for Jira input interactively when it is omitted
+- Saved auto flow configs are discovered at `.agentweaver/flow-configs/<name>.yaml` first and `~/.agentweaver/flow-configs/<name>.yaml` second; the project config wins when both exist
+- Non-dry `agentweaver auto` runs write `flow-config.yaml`, `resolved-flow.json`, and `resolved-flow-summary.json` under `.agentweaver/scopes/<scopeKey>/.artifacts`
+- `auto-golang`, `auto-common-guided`, `auto-common`, `auto-simple`, and configurable `auto` ask for Jira input interactively when Jira input is omitted; leave it empty to paste task text in the next step when Jira is unavailable
 - `task-describe` can also work from manual task description input without Jira
 - `gitlab-review` and `gitlab-diff-review` ask for a GitLab merge request URL interactively
 - `auto-status` and `auto-reset` currently operate on persisted state for `auto-golang`
@@ -361,6 +371,36 @@ Notes:
 
 `auto-simple` is the preserved simplified pipeline: `plan → implement → review loop`, with no planning review gate and no revise rounds. It is behaviorally equivalent to the legacy `auto-common` before the planning gate was introduced.
 
+`agentweaver auto` is the configurable entrypoint in front of those built-in flows. Without flags it resolves to the standard preset, equivalent to `auto-common`. `--preset simple` resolves to the simplified flow, and `--preset standard` resolves to the design-review-gated flow. Use `--dry-run-flow` to inspect the selected source, phase order, included/skipped blocks, max-iteration settings, and artifact policy without invoking LLM executors, command executors, nested flows, state mutation, or resolver artifact writes.
+
+Saved configs are YAML files named by command flag:
+
+```yaml
+kind: auto-flow-config
+version: 1
+name: backend-standard
+basePreset: standard
+slots:
+  designReview:
+    blocks:
+      - id: review.design-loop
+        enabled: true
+        maxIterations: 3
+  postImplementationChecks:
+    blocks:
+      - id: checks.go.linter
+        enabled: true
+        maxIterations: 5
+  review:
+    blocks:
+      - id: review.loop
+        enabled: true
+  final:
+    blocks: []
+```
+
+Supported presets are `simple` and `standard`. Supported slots are `designReview`, `postImplementationChecks`, `review`, and `final`. Supported block ids are `review.design-loop`, `checks.go.linter`, `checks.go.tests`, and `review.loop`. `enabled` accepts `true`, `false`, or `auto`; `maxIterations`, when present, must be a positive integer.
+
 ## Launch Profiles and Resume
 
 Interactive flow runs can ask for an LLM launch profile: executor plus model. That selection is persisted with resumable flow state.
@@ -505,10 +545,10 @@ Use the guided flow with:
 
 ```bash
 agentweaver auto-common-guided --help-phases
-agentweaver auto-common-guided --accept-playbook-draft DEMO-1234
+agentweaver auto-common-guided --accept-playbook-draft [DEMO-1234]
 ```
 
-The workflow does not read old `playbook.json` or `playbook.md` files as fallbacks. In non-interactive runs, a missing manifest stops the workflow before planning and reports the required action: run `agentweaver playbook-init --accept-playbook-draft` first, or rerun `agentweaver auto-common-guided --accept-playbook-draft <jira>`. The `--accept-playbook-draft` flag explicitly accepts the generated playbook without interactive review and allows AgentWeaver to write the manifest-based layout. An invalid manifest stops the guided phase before the LLM prompt.
+The workflow does not read old `playbook.json` or `playbook.md` files as fallbacks. In non-interactive runs, a missing manifest stops the workflow before planning and reports the required action: run `agentweaver playbook-init --accept-playbook-draft` first, or rerun `agentweaver auto-common-guided --accept-playbook-draft [<jira>]` in an interactive terminal when manual task input is needed. The `--accept-playbook-draft` flag explicitly accepts the generated playbook without interactive review and allows AgentWeaver to write the manifest-based layout. An invalid manifest stops the guided phase before the LLM prompt.
 
 To inspect whether playbook guidance participated in a run, check the generated artifacts:
 

package/dist/artifacts.js

@@ -30,6 +30,15 @@ export function artifactManifestSidecarPath(payloadPath) {
 export function artifactIndexFile(scopeKey) {
     return scopeArtifactsFile(scopeKey, "artifact-index.json");
 }
+export function flowConfigYamlFile(scopeKey) {
+    return scopeArtifactsFile(scopeKey, "flow-config.yaml");
+}
+export function resolvedFlowJsonFile(scopeKey) {
+    return scopeArtifactsFile(scopeKey, "resolved-flow.json");
+}
+export function resolvedFlowSummaryJsonFile(scopeKey) {
+    return scopeArtifactsFile(scopeKey, "resolved-flow-summary.json");
+}
 export function taskWorkspaceDir(taskKey) {
     return scopeWorkspaceDir(taskKey);
 }

package/dist/executors/git-commit-executor.js

@@ -1,18 +1,36 @@
+import { selectPathsNeedingGitStage, uniqueGitPaths } from "../git/git-stage-selection.js";
+import { parsePorcelain } from "../git/git-status-parser.js";
 export const gitCommitExecutor = {
     kind: "git-commit",
     version: 1,
     defaultConfig: {},
     async execute(context, input) {
-        if (input.files.length > 0) {
-            await context.runtime.runCommand(["git", "add", ...input.files], {
-                dryRun: context.dryRun,
-                verbose: context.verbose,
-                label: "git add",
-            });
+        const files = uniqueGitPaths(input.files);
+        if (files.length > 0) {
+            let filesToStage = files;
+            if (!context.dryRun) {
+                const statusOutput = await context.runtime.runCommand(["git", "status", "--porcelain", "--", ...files], {
+                    dryRun: false,
+                    verbose: context.verbose,
+                    label: "git status",
+                    printFailureOutput: false,
+                });
+                filesToStage = selectPathsNeedingGitStage(files, parsePorcelain(statusOutput));
+            }
+            if (filesToStage.length > 0) {
+                await context.runtime.runCommand(["git", "add", "-A", "--", ...filesToStage], {
+                    dryRun: context.dryRun,
+                    verbose: context.verbose,
+                    label: "git add",
+                });
+            }
         }
         const commitArgs = input.editEnabled
             ? ["git", "commit", "-e", "-m", input.message]
             : ["git", "commit", "-m", input.message];
+        if (files.length > 0) {
+            commitArgs.push("--", ...files);
+        }
         const output = await context.runtime.runCommand(commitArgs, {
             dryRun: context.dryRun,
             verbose: context.verbose,

package/dist/flow-state.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { ensureScopeWorkspaceDir, flowStateFile } from "./artifacts.js";
 import { TaskRunnerError } from "./errors.js";
+import { isContinuableParentFlowId } from "./pipeline/auto-flow-identity.js";
 import { isFlowRunResumeEnvelope } from "./pipeline/flow-run-resume.js";
 import { resolveStoredExecutionRoutingSnapshot, singleLaunchProfileExecutionRouting } from "./runtime/execution-routing.js";
 const FLOW_STATE_SCHEMA_VERSION = 3;
@@ -12,12 +13,6 @@ const CONTINUABLE_FLOW_KINDS = new Set([
     "run-go-linter-loop-flow",
     "run-go-tests-loop-flow",
 ]);
-const CONTINUABLE_PARENT_FLOW_IDS = new Set([
-    "auto-common",
-    "auto-simple",
-    "auto-golang",
-    "instant-task",
-]);
 const CONTINUABLE_DIRECT_FLOW_IDS = new Set([
     "review-loop",
     "run-go-linter-loop",
@@ -118,7 +113,7 @@ function parseTerminationLocation(terminationReason) {
 function inferContinuationMetadata(flowId, executionState) {
     const stopLocation = parseTerminationLocation(executionState.terminationReason);
     const continueEligible = CONTINUABLE_FLOW_KINDS.has(executionState.flowKind)
-        || (CONTINUABLE_PARENT_FLOW_IDS.has(flowId) && Boolean(stopLocation.stopPhaseId && stopLocation.stopStepId));
+        || (isContinuableParentFlowId(flowId) && Boolean(stopLocation.stopPhaseId && stopLocation.stopStepId));
     return {
         continueEligible,
         ...(stopLocation.stopPhaseId ? { stopPhaseId: stopLocation.stopPhaseId } : {}),
@@ -262,7 +257,7 @@ export function classifyFlowLaunchAvailability(state) {
             },
         restart: {
             available: true,
-            reason: "Archive the active attempt and start a fresh run.",
+            reason: "Start a fresh run.",
         },
     };
     return availability;

package/dist/git/git-diff-parser.js

@@ -0,0 +1,223 @@
+function splitLines(value) {
+    if (!value) {
+        return [];
+    }
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+function parseHunkHeader(line) {
+    const match = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        header: line,
+        oldStart: Number(match[1]),
+        oldLines: Number(match[2] ?? "1"),
+        newStart: Number(match[3]),
+        newLines: Number(match[4] ?? "1"),
+    };
+}
+function normalizeGitPath(value) {
+    return value.replace(/^"?[ab]\//, "").replace(/"$/, "");
+}
+function parseHeaderMetadata(lines) {
+    const metadata = {};
+    for (const line of lines) {
+        if (line.startsWith("rename from ")) {
+            metadata.originalPath = normalizeGitPath(line.slice("rename from ".length));
+        }
+    }
+    return metadata;
+}
+function isBinaryDiff(lines) {
+    return lines.some((line) => (/^Binary files .+ and .+ differ$/.test(line)
+        || line === "GIT binary patch"
+        || line.startsWith("literal ")
+        || line.startsWith("delta ")));
+}
+function pushPairedRows(rows, deletes, adds) {
+    const pairedCount = Math.min(deletes.length, adds.length);
+    for (let index = 0; index < pairedCount; index += 1) {
+        const left = deletes[index];
+        const right = adds[index];
+        rows.push({
+            kind: "modify",
+            leftLineNumber: left.leftLineNumber,
+            rightLineNumber: right.rightLineNumber,
+            leftText: left.text,
+            rightText: right.text,
+        });
+    }
+    for (let index = pairedCount; index < deletes.length; index += 1) {
+        const row = deletes[index];
+        rows.push({
+            kind: "delete",
+            leftLineNumber: row.leftLineNumber,
+            rightLineNumber: null,
+            leftText: row.text,
+            rightText: "",
+        });
+    }
+    for (let index = pairedCount; index < adds.length; index += 1) {
+        const row = adds[index];
+        rows.push({
+            kind: "add",
+            leftLineNumber: null,
+            rightLineNumber: row.rightLineNumber,
+            leftText: "",
+            rightText: row.text,
+        });
+    }
+}
+function normalizeRows(rawRows) {
+    const rows = [];
+    let index = 0;
+    while (index < rawRows.length) {
+        const current = rawRows[index];
+        if (current.kind !== "delete") {
+            rows.push(current.kind === "context"
+                ? {
+                    kind: "context",
+                    leftLineNumber: current.leftLineNumber,
+                    rightLineNumber: current.rightLineNumber,
+                    leftText: current.text,
+                    rightText: current.text,
+                }
+                : {
+                    kind: "add",
+                    leftLineNumber: null,
+                    rightLineNumber: current.rightLineNumber,
+                    leftText: "",
+                    rightText: current.text,
+                });
+            index += 1;
+            continue;
+        }
+        const deletes = [];
+        while (rawRows[index]?.kind === "delete") {
+            deletes.push(rawRows[index]);
+            index += 1;
+        }
+        const adds = [];
+        while (rawRows[index]?.kind === "add") {
+            adds.push(rawRows[index]);
+            index += 1;
+        }
+        if (adds.length > 0) {
+            pushPairedRows(rows, deletes, adds);
+        }
+        else {
+            pushPairedRows(rows, deletes, []);
+        }
+    }
+    return rows;
+}
+export function parseGitDiffOutput(output, options) {
+    const lines = splitLines(output);
+    const metadata = parseHeaderMetadata(lines);
+    if (isBinaryDiff(lines)) {
+        return {
+            mode: options.mode,
+            path: options.path,
+            displayPath: options.displayPath ?? options.path,
+            ...(options.originalPath ?? metadata.originalPath ? { originalPath: options.originalPath ?? metadata.originalPath } : {}),
+            binary: true,
+            tooLarge: false,
+            empty: false,
+            hunks: [],
+            message: "Binary file diff is not displayed.",
+        };
+    }
+    const hunks = [];
+    let current = null;
+    let leftLine = 0;
+    let rightLine = 0;
+    function finishCurrent() {
+        if (!current) {
+            return;
+        }
+        hunks.push({
+            header: current.header,
+            oldStart: current.oldStart,
+            oldLines: current.oldLines,
+            newStart: current.newStart,
+            newLines: current.newLines,
+            rows: normalizeRows(current.rawRows),
+        });
+        current = null;
+    }
+    for (const line of lines) {
+        const header = parseHunkHeader(line);
+        if (header) {
+            finishCurrent();
+            current = { ...header, rawRows: [] };
+            leftLine = header.oldStart;
+            rightLine = header.newStart;
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (line.startsWith("\")) {
+            continue;
+        }
+        const marker = line[0] ?? "";
+        const value = line.length > 0 ? line.slice(1) : "";
+        if (marker === " ") {
+            current.rawRows.push({ kind: "context", leftLineNumber: leftLine, rightLineNumber: rightLine, text: value });
+            leftLine += 1;
+            rightLine += 1;
+        }
+        else if (marker === "-") {
+            current.rawRows.push({ kind: "delete", leftLineNumber: leftLine, rightLineNumber: null, text: value });
+            leftLine += 1;
+        }
+        else if (marker === "+") {
+            current.rawRows.push({ kind: "add", leftLineNumber: null, rightLineNumber: rightLine, text: value });
+            rightLine += 1;
+        }
+    }
+    finishCurrent();
+    return {
+        mode: options.mode,
+        path: options.path,
+        displayPath: options.displayPath ?? options.path,
+        ...(options.originalPath ?? metadata.originalPath ? { originalPath: options.originalPath ?? metadata.originalPath } : {}),
+        binary: false,
+        tooLarge: false,
+        empty: hunks.length === 0 || hunks.every((hunk) => hunk.rows.length === 0),
+        hunks,
+        ...(hunks.length === 0 ? { message: "No diff is available for this mode." } : {}),
+    };
+}
+export function createSyntheticAddedDiff(input) {
+    const lines = splitLines(input.content);
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return {
+        mode: input.mode,
+        path: input.path,
+        displayPath: input.displayPath ?? input.path,
+        binary: false,
+        tooLarge: false,
+        empty: lines.length === 0,
+        hunks: lines.length === 0
+            ? []
+            : [{
+                    header: `@@ -0,0 +1,${lines.length} @@`,
+                    oldStart: 0,
+                    oldLines: 0,
+                    newStart: 1,
+                    newLines: lines.length,
+                    rows: lines.map((line, index) => ({
+                        kind: "add",
+                        leftLineNumber: null,
+                        rightLineNumber: index + 1,
+                        leftText: "",
+                        rightText: line,
+                    })),
+                }],
+        ...(lines.length === 0 ? { message: "Untracked file is empty." } : {}),
+    };
+}