agentweaver 0.1.5 → 0.1.7

package/Dockerfile.codex

@@ -0,0 +1,56 @@
+FROM golang:1.25.5-bookworm
+
+ARG GOLANGCI_LINT_VERSION=v2.7.2
+ARG MOCKGEN_VERSION=v1.6.0
+ARG SWAG_VERSION=latest
+ARG PROTOC_GEN_GO_VERSION=latest
+ARG PROTOC_GEN_GO_GRPC_VERSION=latest
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        ca-certificates \
+        nodejs \
+        npm \
+        curl \
+        jq \
+        less \
+        file \
+        make \
+        procps \
+        ripgrep \
+        git \
+        openssh-client \
+        docker.io \
+        protobuf-compiler \
+        unzip \
+        zip \
+        findutils \
+    && update-ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN if ! getent group 1000 >/dev/null; then groupadd -g 1000 codex; fi \
+    && if ! getent passwd 1000 >/dev/null; then useradd -u 1000 -g 1000 -d /codex-home/home -M -s /bin/bash codex; fi
+
+RUN npm install -g @openai/codex@latest \
+    && npm cache clean --force
+
+RUN GOBIN=/usr/local/bin go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@${GOLANGCI_LINT_VERSION} \
+    && GOBIN=/usr/local/bin go install github.com/golang/mock/mockgen@${MOCKGEN_VERSION} \
+    && GOBIN=/usr/local/bin go install github.com/swaggo/swag/cmd/swag@${SWAG_VERSION} \
+    && GOBIN=/usr/local/bin go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VERSION} \
+    && GOBIN=/usr/local/bin go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${PROTOC_GEN_GO_GRPC_VERSION} \
+    && ln -sf /usr/local/go/bin/go /usr/bin/go \
+    && ln -sf /usr/local/go/bin/gofmt /usr/bin/gofmt
+
+ENV PATH="/usr/local/go/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+
+COPY verify_build.sh /usr/local/bin/verify_build.sh
+COPY run_go_tests.sh /usr/local/bin/run_go_tests.sh
+COPY run_go_linter.sh /usr/local/bin/run_go_linter.sh
+COPY run_go_coverage.sh /usr/local/bin/run_go_coverage.sh
+RUN chmod +x /usr/local/bin/verify_build.sh /usr/local/bin/run_go_tests.sh /usr/local/bin/run_go_linter.sh /usr/local/bin/run_go_coverage.sh
+
+WORKDIR /workspace
+
+ENTRYPOINT ["codex"]
+CMD ["--dangerously-bypass-approvals-and-sandbox"]

package/README.md

@@ -1,19 +1,21 @@
 # AgentWeaver
 
-`AgentWeaver` is a TypeScript/Node.js CLI for engineering workflows around Jira, Codex, and Claude.
+`AgentWeaver` is a TypeScript/Node.js CLI for engineering workflows around Jira, GitLab review artifacts, Codex, and Claude.
 
 It orchestrates a flow like:
 
-`plan -> implement -> test -> review -> review-fix -> test`
+`plan -> implement -> run-go-linter-loop -> run-go-tests-loop -> review -> review-fix`
 
 The package is designed to run as an npm CLI and includes an interactive terminal UI built on `neo-blessed`.
 
 ## What It Does
 
 - Fetches a Jira issue by key or browse URL
+- Fetches GitLab merge request review comments into reusable markdown and JSON artifacts
 - Generates workflow artifacts such as design, implementation plan, QA plan, bug analysis, reviews, and summaries
-- Machine-readable JSON artifacts are stored under `.agentweaver-<TASK>/.artifacts/` and act as the source of truth between workflow steps; Markdown artifacts remain for human inspection
-- Runs workflow stages like `bug-analyze`, `bug-fix`, `mr-description`, `plan`, `task-describe`, `implement`, `review`, `review-fix`, `test`, and `auto`
+- Machine-readable JSON artifacts are stored under `.agentweaver/scopes/<scope-key>/.artifacts/` and act as the source of truth between workflow steps; Markdown artifacts remain for human inspection
+- Workflow artifacts are isolated by scope; for Jira-driven flows the scope key defaults to the Jira task key, otherwise it defaults to `<git-branch>--<worktree-hash>`
+- Runs workflow stages like `bug-analyze`, `bug-fix`, `mr-description`, `plan`, `task-describe`, `implement`, `review`, `review-fix`, `run-go-tests-loop`, `run-go-linter-loop`, and `auto`
 - Persists compact `auto` pipeline state on disk so runs can resume without storing large agent outputs
 - Uses Docker runtime services for isolated Codex execution and build verification
 
@@ -22,9 +24,9 @@ The package is designed to run as an npm CLI and includes an interactive termina
 The CLI now uses an executor + node + declarative flow architecture.
 
 - `src/index.ts` remains the CLI entrypoint and high-level orchestration layer
-- `src/executors/` contains first-class executors for external actions such as Jira fetch, local Codex, Docker-based build verification, Claude, Claude summaries, and process execution
+- `src/executors/` contains first-class executors for external actions such as Jira fetch, GitLab review fetch, local Codex, Docker-based build verification, Claude, Claude summaries, and process execution
 - `src/pipeline/nodes/` contains reusable runtime nodes built on top of executors
-- `src/pipeline/flow-specs/` contains declarative JSON flow specs for `preflight`, `bug-analyze`, `bug-fix`, `mr-description`, `plan`, `task-describe`, `implement`, `review`, `review-fix`, `test`, `test-fix`, `test-linter-fix`, `run-tests-loop`, `run-linter-loop`, and `auto`
+- `src/pipeline/flow-specs/` contains declarative JSON flow specs for `preflight`, `bug-analyze`, `bug-fix`, `gitlab-review`, `mr-description`, `plan`, `task-describe`, `implement`, `review`, `review-fix`, `run-go-tests-loop`, `run-go-linter-loop`, and `auto`
 - `src/runtime/` contains shared runtime services such as command resolution, Docker runtime environment setup, and subprocess execution
 
 This keeps command handlers focused on choosing a flow and providing parameters instead of assembling prompts and subprocess wiring inline.
@@ -43,8 +45,9 @@ This keeps command handlers focused on choosing a flow and providing parameters
 - `docker-compose.yml` — runtime services for Codex and build verification
 - `Dockerfile.codex` — container image for Codex runtime
 - `verify_build.sh` — aggregated verification entrypoint used by `verify-build`
-- `run_tests.sh` — isolated test and coverage verification entrypoint
-- `run_linter.sh` — isolated generate + lint verification entrypoint
+- `run_go_tests.sh` — isolated Go test verification entrypoint
+- `run_go_linter.sh` — isolated Go generate + lint verification entrypoint
+- `run_go_coverage.sh` — isolated Go coverage verification entrypoint
 - `package.json` — npm package metadata and scripts
 - `tsconfig.json` — TypeScript configuration
 
@@ -86,6 +89,7 @@ Required:
 Common optional variables:
 
 - `JIRA_BASE_URL` — required when you pass only an issue key like `DEMO-123`
+- `GITLAB_TOKEN` — personal access token for `gitlab-review`
 - `AGENTWEAVER_HOME` — path to the AgentWeaver installation directory
 - `DOCKER_COMPOSE_BIN` — override compose command, for example `docker compose`
 - `CODEX_BIN` — override `codex` executable path
@@ -115,14 +119,19 @@ Direct CLI usage:
 
 ```bash
 agentweaver plan DEMO-3288
+agentweaver plan
 agentweaver bug-analyze DEMO-3288
 agentweaver bug-fix DEMO-3288
+agentweaver gitlab-review DEMO-3288
 agentweaver mr-description DEMO-3288
 agentweaver task-describe DEMO-3288
 agentweaver implement DEMO-3288
+agentweaver review
 agentweaver review DEMO-3288
-agentweaver run-tests-loop DEMO-3288
-agentweaver run-linter-loop DEMO-3288
+agentweaver review --scope release-prep
+agentweaver run-go-tests-loop DEMO-3288
+agentweaver run-go-tests-loop
+agentweaver run-go-linter-loop DEMO-3288
 agentweaver auto DEMO-3288
 ```
 
@@ -130,10 +139,13 @@ From source checkout:
 
 ```bash
 node dist/index.js plan DEMO-3288
+node dist/index.js plan
 node dist/index.js bug-analyze DEMO-3288
 node dist/index.js bug-fix DEMO-3288
+node dist/index.js gitlab-review DEMO-3288
 node dist/index.js mr-description DEMO-3288
 node dist/index.js task-describe DEMO-3288
+node dist/index.js review
 node dist/index.js auto DEMO-3288
 ```
 
@@ -141,6 +153,7 @@ Interactive mode:
 
 ```bash
 agentweaver DEMO-3288
+agentweaver
 ```
 
 When you run from a working project directory, set `AGENTWEAVER_HOME` to the AgentWeaver installation:
@@ -161,6 +174,9 @@ agentweaver auto-reset DEMO-3288
 Notes:
 
 - `--verbose` streams child process `stdout/stderr` in direct CLI mode
+- task-only commands such as `plan` and `auto` ask for Jira task via interactive `user-input` when it is omitted
+- scope-flexible commands such as `review`, `review-fix`, `run-go-tests-loop`, and `run-go-linter-loop` use the current git branch by default when Jira task is omitted
+- `--scope <name>` lets you override the default project scope name
 - the interactive `Activity` pane is intentionally structured: it shows launch separators, prompts, summaries, and short status messages instead of raw Codex/Claude logs by default
 
 ## Interactive TUI
@@ -189,15 +205,16 @@ Activity pane behavior:
 
 ## Docker Runtime
 
-Docker is used as an isolated execution environment for Codex and build/test verification.
+Docker is used as an isolated execution environment for Codex-related runtime scenarios that still require container orchestration.
 
 Main services:
 
 - `codex` — interactive Codex container
 - `codex-exec` — non-interactive `codex exec`
 - `verify-build` — project verification script inside container
-- `run-tests` — isolated `run_tests.sh` execution inside container
-- `run-linter` — isolated `run_linter.sh` execution inside container
+- `run-go-tests` — isolated `run_go_tests.sh` execution inside container
+- `run-go-linter` — isolated `run_go_linter.sh` execution inside container
+- `run-go-coverage` — isolated `run_go_coverage.sh` execution inside container
 - `codex-login` — interactive login container
 - `dockerd` — internal Docker daemon for testcontainers/build flows
 
@@ -230,13 +247,19 @@ PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run
 Tests only:
 
 ```bash
-PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run --rm run-tests
+PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run --rm run-go-tests
 ```
 
 Linter only:
 
 ```bash
-PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run --rm run-linter
+PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run --rm run-go-linter
+```
+
+Coverage only:
+
+```bash
+PROJECT_DIR="$PWD" docker compose -f "$AGENTWEAVER_HOME/docker-compose.yml" run --rm run-go-coverage
 ```
 
 ## Development

package/dist/artifacts.js

@@ -5,23 +5,41 @@ import { TaskRunnerError } from "./errors.js";
 export const REVIEW_FILE_RE = /^review-(.+)-(\d+)\.md$/;
 export const REVIEW_REPLY_FILE_RE = /^review-reply-(.+)-(\d+)\.md$/;
 export const READY_TO_MERGE_FILE = "ready-to-merge.md";
-export function taskWorkspaceDir(taskKey) {
-    return path.join(process.cwd(), `.agentweaver-${taskKey}`);
+export function scopesRootDir() {
+    return path.join(process.cwd(), ".agentweaver", "scopes");
 }
-export function ensureTaskWorkspaceDir(taskKey) {
-    const workspaceDir = taskWorkspaceDir(taskKey);
+export function scopeWorkspaceDir(scopeKey) {
+    return path.join(scopesRootDir(), scopeKey);
+}
+export function ensureScopeWorkspaceDir(scopeKey) {
+    const workspaceDir = scopeWorkspaceDir(scopeKey);
     mkdirSync(workspaceDir, { recursive: true });
-    mkdirSync(taskArtifactsDir(taskKey), { recursive: true });
+    mkdirSync(scopeArtifactsDir(scopeKey), { recursive: true });
     return workspaceDir;
 }
+export function scopeWorkspaceFile(scopeKey, fileName) {
+    return path.join(scopeWorkspaceDir(scopeKey), fileName);
+}
+export function scopeArtifactsDir(scopeKey) {
+    return path.join(scopeWorkspaceDir(scopeKey), ".artifacts");
+}
+export function scopeArtifactsFile(scopeKey, fileName) {
+    return path.join(scopeArtifactsDir(scopeKey), fileName);
+}
+export function taskWorkspaceDir(taskKey) {
+    return scopeWorkspaceDir(taskKey);
+}
+export function ensureTaskWorkspaceDir(taskKey) {
+    return ensureScopeWorkspaceDir(taskKey);
+}
 export function taskWorkspaceFile(taskKey, fileName) {
-    return path.join(taskWorkspaceDir(taskKey), fileName);
+    return scopeWorkspaceFile(taskKey, fileName);
 }
 export function taskArtifactsDir(taskKey) {
-    return path.join(taskWorkspaceDir(taskKey), ".artifacts");
+    return scopeArtifactsDir(taskKey);
 }
 export function taskArtifactsFile(taskKey, fileName) {
-    return path.join(taskArtifactsDir(taskKey), fileName);
+    return scopeArtifactsFile(taskKey, fileName);
 }
 export function artifactFile(prefix, taskKey, iteration) {
     return taskWorkspaceFile(taskKey, `${prefix}-${taskKey}-${iteration}.md`);
@@ -89,9 +107,21 @@ export function mrDescriptionFile(taskKey) {
 export function mrDescriptionJsonFile(taskKey) {
     return taskArtifactsFile(taskKey, `mr-description-${taskKey}.json`);
 }
+export function gitlabReviewFile(taskKey) {
+    return taskWorkspaceFile(taskKey, `gitlab-review-${taskKey}.md`);
+}
+export function gitlabReviewJsonFile(taskKey) {
+    return taskArtifactsFile(taskKey, `gitlab-review-${taskKey}.json`);
+}
+export function gitlabReviewInputJsonFile(taskKey) {
+    return taskArtifactsFile(taskKey, `gitlab-review-input-${taskKey}.json`);
+}
 export function autoStateFile(taskKey) {
     return taskArtifactsFile(taskKey, `.agentweaver-state-${taskKey}.json`);
 }
+export function flowStateFile(scopeKey, flowId) {
+    return scopeArtifactsFile(scopeKey, `.agentweaver-flow-state-${flowId}.json`);
+}
 export function planArtifacts(taskKey) {
     return [designFile(taskKey), designJsonFile(taskKey), planFile(taskKey), planJsonFile(taskKey), qaFile(taskKey), qaJsonFile(taskKey)];
 }

package/dist/executors/configs/fetch-gitlab-review-config.js

@@ -0,0 +1,3 @@
+export const fetchGitLabReviewExecutorDefaultConfig = {
+    authEnvVar: "GITLAB_TOKEN",
+};

package/dist/executors/fetch-gitlab-review-executor.js

@@ -0,0 +1,25 @@
+import { fetchGitLabReviewExecutorDefaultConfig } from "./configs/fetch-gitlab-review-config.js";
+import { buildGitLabReviewFetchTarget, fetchGitLabReview } from "../gitlab.js";
+export const fetchGitLabReviewExecutor = {
+    kind: "fetch-gitlab-review",
+    version: 1,
+    defaultConfig: fetchGitLabReviewExecutorDefaultConfig,
+    async execute(context, input) {
+        const target = buildGitLabReviewFetchTarget(input.mergeRequestUrl);
+        if (context.verbose) {
+            context.ui.writeStdout(`GitLab MR URL: ${target.mergeRequestUrl}\n`);
+            context.ui.writeStdout(`GitLab project path: ${target.projectPath}\n`);
+            context.ui.writeStdout(`GitLab merge request IID: ${target.mergeRequestIid}\n`);
+            context.ui.writeStdout(`GitLab discussions API URL: ${target.discussionsApiUrl}\n`);
+            context.ui.writeStdout(`Saving GitLab review markdown to: ${input.outputFile}\n`);
+            context.ui.writeStdout(`Saving GitLab review JSON to: ${input.outputJsonFile}\n`);
+        }
+        const artifact = await fetchGitLabReview(input.mergeRequestUrl, input.outputFile, input.outputJsonFile);
+        return {
+            outputFile: input.outputFile,
+            outputJsonFile: input.outputJsonFile,
+            mergeRequestUrl: artifact.merge_request_url,
+            commentsCount: artifact.comments.length,
+        };
+    },
+};

package/dist/flow-state.js

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { ensureScopeWorkspaceDir, flowStateFile } from "./artifacts.js";
+import { TaskRunnerError } from "./errors.js";
+const FLOW_STATE_SCHEMA_VERSION = 1;
+function nowIso8601() {
+    return new Date().toISOString();
+}
+export function stripExecutionStatePayload(executionState) {
+    return {
+        flowKind: executionState.flowKind,
+        flowVersion: executionState.flowVersion,
+        terminated: executionState.terminated,
+        ...(executionState.terminationReason ? { terminationReason: executionState.terminationReason } : {}),
+        phases: executionState.phases.map((phase) => ({
+            id: phase.id,
+            status: phase.status,
+            repeatVars: { ...phase.repeatVars },
+            ...(phase.startedAt ? { startedAt: phase.startedAt } : {}),
+            ...(phase.finishedAt ? { finishedAt: phase.finishedAt } : {}),
+            steps: phase.steps.map((step) => ({
+                id: step.id,
+                status: step.status,
+                ...(step.outputs ? { outputs: step.outputs } : {}),
+                ...(step.value !== undefined ? { value: step.value } : {}),
+                ...(step.startedAt ? { startedAt: step.startedAt } : {}),
+                ...(step.finishedAt ? { finishedAt: step.finishedAt } : {}),
+                ...(step.stopFlow !== undefined ? { stopFlow: step.stopFlow } : {}),
+            })),
+        })),
+    };
+}
+export function createFlowRunState(scopeKey, flowId, executionState) {
+    return {
+        schemaVersion: FLOW_STATE_SCHEMA_VERSION,
+        flowId,
+        scopeKey,
+        status: "pending",
+        currentStep: null,
+        updatedAt: nowIso8601(),
+        executionState: stripExecutionStatePayload(executionState),
+    };
+}
+export function loadFlowRunState(scopeKey, flowId) {
+    const filePath = flowStateFile(scopeKey, flowId);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to parse flow state file ${filePath}: ${error.message}`);
+    }
+    if (!raw || typeof raw !== "object") {
+        throw new TaskRunnerError(`Invalid flow state file format: ${filePath}`);
+    }
+    const state = raw;
+    if (state.schemaVersion !== FLOW_STATE_SCHEMA_VERSION) {
+        throw new TaskRunnerError(`Unsupported flow state schema in ${filePath}: ${state.schemaVersion}`);
+    }
+    if (state.flowId !== flowId) {
+        throw new TaskRunnerError(`Flow state ${filePath} belongs to flow '${state.flowId}', expected '${flowId}'`);
+    }
+    return state;
+}
+export function saveFlowRunState(state) {
+    state.updatedAt = nowIso8601();
+    ensureScopeWorkspaceDir(state.scopeKey);
+    writeFileSync(flowStateFile(state.scopeKey, state.flowId), `${JSON.stringify({
+        ...state,
+        executionState: stripExecutionStatePayload(state.executionState),
+    }, null, 2)}\n`, "utf8");
+}
+export function resetFlowRunState(scopeKey, flowId) {
+    const filePath = flowStateFile(scopeKey, flowId);
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    rmSync(filePath);
+    return true;
+}
+export function hasResumableFlowState(state) {
+    if (!state) {
+        return false;
+    }
+    if (state.executionState.terminated) {
+        return false;
+    }
+    if (state.status === "completed") {
+        return false;
+    }
+    if (state.status === "running" || state.status === "blocked") {
+        return true;
+    }
+    return state.executionState.phases.some((phase) => phase.steps.some((step) => step.status === "done" || step.status === "running"));
+}
+function normalizeStepState(step) {
+    if (step.status !== "running") {
+        return step;
+    }
+    const { finishedAt: _finishedAt, outputs: _outputs, value: _value, stopFlow: _stopFlow, ...rest } = step;
+    return {
+        ...rest,
+        status: "pending",
+    };
+}
+function normalizePhaseState(phase) {
+    const normalizedSteps = phase.steps.map(normalizeStepState);
+    if (phase.status !== "running") {
+        return {
+            ...phase,
+            steps: normalizedSteps,
+        };
+    }
+    const { finishedAt: _finishedAt, ...rest } = phase;
+    return {
+        ...rest,
+        status: "pending",
+        steps: normalizedSteps,
+    };
+}
+export function prepareFlowStateForResume(state) {
+    state.status = "pending";
+    state.lastError = null;
+    state.currentStep = null;
+    state.executionState = {
+        ...state.executionState,
+        terminated: false,
+        phases: state.executionState.phases.map(normalizePhaseState),
+    };
+    delete state.executionState.terminationReason;
+    return state;
+}

package/dist/gitlab.js

@@ -0,0 +1,153 @@
+import { mkdirSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { TaskRunnerError } from "./errors.js";
+const MERGE_REQUEST_PATH_RE = /^(?<projectPath>.+?)\/-\/merge_requests\/(?<iid>\d+)(?:\/.*)?$/;
+function normalizeUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+function normalizeProjectPath(value) {
+    return value.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+export function parseGitLabMergeRequestUrl(mergeRequestUrl) {
+    let parsed;
+    try {
+        parsed = new URL(normalizeUrl(mergeRequestUrl));
+    }
+    catch {
+        throw new TaskRunnerError("Expected GitLab merge request URL like https://gitlab.example.com/group/project/-/merge_requests/123");
+    }
+    const match = MERGE_REQUEST_PATH_RE.exec(parsed.pathname);
+    const projectPath = normalizeProjectPath(match?.groups?.projectPath ?? "");
+    const iidRaw = match?.groups?.iid;
+    if (!projectPath || !iidRaw) {
+        throw new TaskRunnerError("Expected GitLab merge request URL like https://gitlab.example.com/group/project/-/merge_requests/123");
+    }
+    return {
+        apiBaseUrl: `${parsed.protocol}//${parsed.host}/api/v4`,
+        mergeRequestUrl: `${parsed.protocol}//${parsed.host}${parsed.pathname}`,
+        projectPath,
+        mergeRequestIid: Number.parseInt(iidRaw, 10),
+    };
+}
+export function buildGitLabReviewFetchTarget(mergeRequestUrl) {
+    const mergeRequestRef = parseGitLabMergeRequestUrl(mergeRequestUrl);
+    return {
+        ...mergeRequestRef,
+        discussionsApiUrl: `${mergeRequestRef.apiBaseUrl}/projects/${encodeURIComponent(mergeRequestRef.projectPath)}/merge_requests/${mergeRequestRef.mergeRequestIid}/discussions`,
+    };
+}
+async function fetchDiscussionPage(target, page, token) {
+    const apiUrl = `${target.discussionsApiUrl}?per_page=100&page=${page}`;
+    const response = await fetch(apiUrl, {
+        headers: {
+            "PRIVATE-TOKEN": token,
+            Accept: "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new TaskRunnerError([
+            `Failed to fetch GitLab merge request discussions: HTTP ${response.status}`,
+            `MR URL: ${target.mergeRequestUrl}`,
+            `GitLab project path: ${target.projectPath}`,
+            `GitLab merge request IID: ${target.mergeRequestIid}`,
+            `GitLab discussions API URL: ${apiUrl}`,
+        ].join("\n"));
+    }
+    const nextPageHeader = response.headers.get("x-next-page");
+    const nextPage = nextPageHeader && nextPageHeader.trim().length > 0 ? Number.parseInt(nextPageHeader, 10) : null;
+    const discussions = (await response.json());
+    return { discussions, nextPage: Number.isNaN(nextPage ?? Number.NaN) ? null : nextPage };
+}
+async function fetchMergeRequestDiscussions(target, token) {
+    const discussions = [];
+    let page = 1;
+    while (true) {
+        const chunk = await fetchDiscussionPage(target, page, token);
+        discussions.push(...chunk.discussions);
+        if (!chunk.nextPage) {
+            return discussions;
+        }
+        page = chunk.nextPage;
+    }
+}
+function normalizeDiscussionNotes(discussions) {
+    return discussions.flatMap((discussion) => {
+        const discussionId = String(discussion.id ?? "");
+        if (!discussionId) {
+            return [];
+        }
+        return (discussion.notes ?? [])
+            .filter((note) => typeof note.body === "string" && note.body.trim().length > 0)
+            .filter((note) => note.system !== true)
+            .map((note) => ({
+            id: String(note.id ?? `${discussionId}-${note.created_at ?? "unknown"}`),
+            discussion_id: discussionId,
+            body: note.body?.trim() ?? "",
+            author: note.author?.username?.trim() || note.author?.name?.trim() || "unknown",
+            created_at: note.created_at ?? new Date(0).toISOString(),
+            system: Boolean(note.system),
+            resolvable: Boolean(note.resolvable),
+            resolved: Boolean(note.resolved),
+            file_path: note.position?.new_path ?? note.position?.old_path ?? null,
+            new_line: typeof note.position?.new_line === "number" ? note.position.new_line : null,
+            old_line: typeof note.position?.old_line === "number" ? note.position.old_line : null,
+        }));
+    });
+}
+function buildGitLabReviewMarkdown(artifact) {
+    const lines = [
+        "# GitLab Review",
+        "",
+        `- MR: ${artifact.merge_request_url}`,
+        `- Project: ${artifact.project_path}`,
+        `- IID: ${artifact.merge_request_iid}`,
+        `- Fetched at: ${artifact.fetched_at}`,
+        `- Comments: ${artifact.comments.length}`,
+        "",
+    ];
+    if (artifact.comments.length === 0) {
+        lines.push("Код-ревью комментариев не найдено.");
+        return lines.join("\n");
+    }
+    artifact.comments.forEach((comment, index) => {
+        lines.push(`## Comment ${index + 1}`);
+        lines.push(`- Author: ${comment.author}`);
+        lines.push(`- Created at: ${comment.created_at}`);
+        lines.push(`- Discussion: ${comment.discussion_id}`);
+        if (comment.file_path) {
+            const location = [comment.file_path, comment.new_line ?? comment.old_line].filter((item) => item !== null).join(":");
+            lines.push(`- Location: ${location}`);
+        }
+        if (comment.resolvable) {
+            lines.push(`- Resolved: ${comment.resolved ? "yes" : "no"}`);
+        }
+        lines.push("");
+        lines.push(comment.body);
+        lines.push("");
+    });
+    return lines.join("\n");
+}
+export async function fetchGitLabReview(mergeRequestUrl, outputFile, outputJsonFile) {
+    const token = process.env.GITLAB_TOKEN?.trim();
+    if (!token) {
+        throw new TaskRunnerError("GITLAB_TOKEN is required for gitlab-review flow.");
+    }
+    const target = buildGitLabReviewFetchTarget(mergeRequestUrl);
+    const discussions = await fetchMergeRequestDiscussions(target, token);
+    const comments = normalizeDiscussionNotes(discussions);
+    const fetchedAt = new Date().toISOString();
+    const artifact = {
+        summary: comments.length > 0 ? `Fetched ${comments.length} GitLab review comments.` : "No GitLab review comments found.",
+        merge_request_url: target.mergeRequestUrl,
+        project_path: target.projectPath,
+        merge_request_iid: target.mergeRequestIid,
+        fetched_at: fetchedAt,
+        comments,
+    };
+    mkdirSync(path.dirname(outputFile), { recursive: true });
+    mkdirSync(path.dirname(outputJsonFile), { recursive: true });
+    await writeFile(outputJsonFile, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+    await writeFile(outputFile, `${buildGitLabReviewMarkdown(artifact)}\n`, "utf8");
+    return artifact;
+}