agentweaver 0.1.6 → 0.1.8

package/Dockerfile.codex

@@ -45,9 +45,10 @@ RUN GOBIN=/usr/local/bin go install github.com/golangci/golangci-lint/v2/cmd/gol
 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_tests.sh /usr/local/bin/run_tests.sh
-COPY run_linter.sh /usr/local/bin/run_linter.sh
-RUN chmod +x /usr/local/bin/verify_build.sh /usr/local/bin/run_tests.sh /usr/local/bin/run_linter.sh
+COPY run_go_tests.py /usr/local/bin/run_go_tests.py
+COPY run_go_linter.py /usr/local/bin/run_go_linter.py
+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.py /usr/local/bin/run_go_linter.py /usr/local/bin/run_go_coverage.sh
 
 WORKDIR /workspace
 

package/README.md

@@ -4,7 +4,7 @@
 
 It orchestrates a flow like:
 
-`plan -> implement -> run-linter-loop -> run-tests-loop -> review -> review-fix`
+`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`.
 
@@ -13,8 +13,9 @@ The package is designed to run as an npm CLI and includes an interactive termina
 - 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`, `run-tests-loop`, `run-linter-loop`, 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
 
@@ -25,7 +26,7 @@ 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, 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`, `gitlab-review`, `mr-description`, `plan`, `task-describe`, `implement`, `review`, `review-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.
@@ -44,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.py` — isolated Go test verification entrypoint
+- `run_go_linter.py` — 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
 
@@ -117,15 +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
 ```
 
@@ -133,11 +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
 ```
 
@@ -145,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:
@@ -165,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
@@ -200,8 +212,9 @@ 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.py` execution inside container
+- `run-go-linter` — isolated `run_go_linter.py` 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
 
@@ -234,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`);
@@ -101,6 +119,9 @@ export function gitlabReviewInputJsonFile(taskKey) {
 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)];
 }
@@ -135,6 +156,12 @@ export function reviewFixJsonFile(taskKey, iteration) {
 export function reviewFixSelectionJsonFile(taskKey, iteration) {
     return artifactJsonFile("review-fix-selection", taskKey, iteration);
 }
+export function runGoLinterResultJsonFile(taskKey, iteration) {
+    return artifactJsonFile("run-go-linter-result", taskKey, iteration);
+}
+export function runGoTestsResultJsonFile(taskKey, iteration) {
+    return artifactJsonFile("run-go-tests-result", taskKey, iteration);
+}
 export function requireArtifacts(paths, message) {
     const missing = paths.filter((filePath) => !existsSync(filePath));
     if (missing.length > 0) {

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;
+}