agentweaver 0.1.5 → 0.1.7

package/run_go_linter.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="${VERIFY_BUILD_ROOT_DIR:-$(pwd)}"
+
+log() {
+  printf '%s\n' "$*" >&2
+}
+
+details_json() {
+  local template="${@: -1}"
+  local argc=$#
+  local jq_args=()
+  if (( argc > 1 )); then
+    jq_args=("${@:1:argc-1}")
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    jq -cn "${jq_args[@]}" "$template"
+  else
+    printf '{}'
+  fi
+}
+
+emit_result() {
+  local ok="$1"
+  local kind="$2"
+  local stage="$3"
+  local exit_code="$4"
+  local summary="$5"
+  local command="$6"
+  local details_json="${7:-{}}"
+
+  if ! command -v jq >/dev/null 2>&1; then
+    printf '{"ok":%s,"kind":"%s","stage":"%s","exitCode":%s,"summary":"%s","command":"%s","details":{"error":"jq is required for structured output"}}\n' \
+      "$ok" "$kind" "$stage" "$exit_code" "$summary" "$command"
+    return
+  fi
+
+  jq -cn \
+    --arg ok "$ok" \
+    --arg kind "$kind" \
+    --arg stage "$stage" \
+    --arg exitCode "$exit_code" \
+    --arg summary "$summary" \
+    --arg command "$command" \
+    --arg details "$details_json" \
+    '{
+      ok: ($ok == "true"),
+      kind: $kind,
+      stage: $stage,
+      exitCode: ($exitCode | tonumber),
+      summary: $summary,
+      command: $command,
+      details: ($details | fromjson? // {raw: $details})
+    }'
+}
+
+fail() {
+  local exit_code="$1"
+  local summary="$2"
+  local command="$3"
+  local details_json="${4:-{}}"
+
+  emit_result false "linter" "run_go_linter" "$exit_code" "$summary" "$command" "$details_json"
+  exit "$exit_code"
+}
+
+require_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    fail 2 "Missing required command: $1" "$1" "$(details_json --arg failedStep "require_cmd" --arg missingCommand "$1" '{failedStep: $failedStep, missingCommand: $missingCommand}')"
+  fi
+}
+
+require_cmd go
+require_cmd golangci-lint
+cd "$ROOT_DIR"
+
+log "==> Generating code (go generate ./...)"
+if ! go generate ./... >&2; then
+  fail 1 "go generate failed" "go generate ./..." '{"failedStep":"go-generate"}'
+fi
+
+log "==> Running linter (golangci-lint run)"
+if ! golangci-lint run >&2; then
+  fail 1 "golangci-lint failed" "golangci-lint run" '{"failedStep":"golangci-lint"}'
+fi
+
+emit_result true "linter" "run_go_linter" 0 "Linter checks passed" "go generate ./... && golangci-lint run" "$(details_json '{steps:["go-generate","golangci-lint"]}')"

package/run_go_tests.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="${VERIFY_BUILD_ROOT_DIR:-$(pwd)}"
+
+log() {
+  printf '%s\n' "$*" >&2
+}
+
+details_json() {
+  local template="${@: -1}"
+  local argc=$#
+  local jq_args=()
+  if (( argc > 1 )); then
+    jq_args=("${@:1:argc-1}")
+  fi
+  if command -v jq >/dev/null 2>&1; then
+    jq -cn "${jq_args[@]}" "$template"
+  else
+    printf '{}'
+  fi
+}
+
+emit_result() {
+  local ok="$1"
+  local kind="$2"
+  local stage="$3"
+  local exit_code="$4"
+  local summary="$5"
+  local command="$6"
+  local details_json="${7:-{}}"
+
+  if ! command -v jq >/dev/null 2>&1; then
+    printf '{"ok":%s,"kind":"%s","stage":"%s","exitCode":%s,"summary":"%s","command":"%s","details":{"error":"jq is required for structured output"}}\n' \
+      "$ok" "$kind" "$stage" "$exit_code" "$summary" "$command"
+    return
+  fi
+
+  jq -cn \
+    --arg ok "$ok" \
+    --arg kind "$kind" \
+    --arg stage "$stage" \
+    --arg exitCode "$exit_code" \
+    --arg summary "$summary" \
+    --arg command "$command" \
+    --arg details "$details_json" \
+    '{
+      ok: ($ok == "true"),
+      kind: $kind,
+      stage: $stage,
+      exitCode: ($exitCode | tonumber),
+      summary: $summary,
+      command: $command,
+      details: ($details | fromjson? // {raw: $details})
+    }'
+}
+
+fail() {
+  local exit_code="$1"
+  local summary="$2"
+  local command="$3"
+  local details_json="${4:-{}}"
+
+  emit_result false "tests" "run_go_tests" "$exit_code" "$summary" "$command" "$details_json"
+  exit "$exit_code"
+}
+
+require_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    fail 2 "Missing required command: $1" "$1" "$(details_json --arg failedStep "require_cmd" --arg missingCommand "$1" '{failedStep: $failedStep, missingCommand: $missingCommand}')"
+  fi
+}
+
+require_cmd go
+cd "$ROOT_DIR"
+
+log "==> Running unit tests (go test -count=1 ./...)"
+if ! go test -count=1 ./... >&2; then
+  fail 1 "go test failed" "go test -count=1 ./..." '{"failedStep":"go-test"}'
+fi
+
+emit_result true "tests" "run_go_tests" 0 "Tests passed" "go test -count=1 ./..." "$(details_json '{steps:["go-test"]}')"

package/verify_build.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="${VERIFY_BUILD_ROOT_DIR:-$(pwd)}"
+BUILD_TARGET="./cmd/user-service"
+BUILD_OUTPUT="$ROOT_DIR/user-service"
+
+log() {
+  printf '%s\n' "$*" >&2
+}
+
+details_json() {
+  local template="$1"
+  shift
+  if command -v jq >/dev/null 2>&1; then
+    jq -cn "$@" "$template"
+  else
+    printf '{}'
+  fi
+}
+
+emit_result() {
+  local ok="$1"
+  local kind="$2"
+  local stage="$3"
+  local exit_code="$4"
+  local summary="$5"
+  local command="$6"
+  local details_json="${7:-{}}"
+
+  if ! command -v jq >/dev/null 2>&1; then
+    printf '{"ok":%s,"kind":"%s","stage":"%s","exitCode":%s,"summary":"%s","command":"%s","details":{"error":"jq is required for structured output"}}\n' \
+      "$ok" "$kind" "$stage" "$exit_code" "$summary" "$command"
+    return
+  fi
+
+  jq -cn \
+    --arg ok "$ok" \
+    --arg kind "$kind" \
+    --arg stage "$stage" \
+    --arg exitCode "$exit_code" \
+    --arg summary "$summary" \
+    --arg command "$command" \
+    --arg details "$details_json" \
+    '{
+      ok: ($ok == "true"),
+      kind: $kind,
+      stage: $stage,
+      exitCode: ($exitCode | tonumber),
+      summary: $summary,
+      command: $command,
+      details: ($details | fromjson? // {raw: $details})
+    }'
+}
+
+fail() {
+  local exit_code="$1"
+  local summary="$2"
+  local command="$3"
+  local details_json="${4:-{}}"
+
+  emit_result false "verify-build" "verify_build" "$exit_code" "$summary" "$command" "$details_json"
+  exit "$exit_code"
+}
+
+require_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    fail 2 "Missing required command: $1" "$1" "$(details_json --arg failedStage "require_cmd" --arg missingCommand "$1" '{failedStage: $failedStage, missingCommand: $missingCommand}')"
+  fi
+}
+
+run_stage() {
+  local stage_name="$1"
+  local script_path="$2"
+  local output
+  local exit_code=0
+
+  if output=$("$script_path"); then
+    :
+  else
+    exit_code=$?
+  fi
+
+  printf '%s\n' "$output" >&2
+
+  if [[ "$exit_code" -ne 0 ]]; then
+    fail "$exit_code" "${stage_name} stage failed" "$script_path" "$(details_json --arg failedStage "$stage_name" --arg rawOutput "$output" '{failedStage: $failedStage, stageResult: ($rawOutput | fromjson? // {raw: $rawOutput})}')"
+  fi
+}
+
+require_cmd go
+
+cd "$ROOT_DIR"
+
+run_stage "run_go_linter" "$ROOT_DIR/run_go_linter.sh"
+run_stage "run_go_tests" "$ROOT_DIR/run_go_tests.sh"
+run_stage "run_go_coverage" "$ROOT_DIR/run_go_coverage.sh"
+
+log "==> Building binary (go build ${BUILD_TARGET})"
+if ! go build -o "$BUILD_OUTPUT" "$BUILD_TARGET" >&2; then
+  fail 1 "go build failed" "go build -o <output> ./cmd/user-service" "$(details_json --arg failedStage "go-build" --arg buildTarget "$BUILD_TARGET" --arg buildOutput "$BUILD_OUTPUT" '{failedStage: $failedStage, buildTarget: $buildTarget, buildOutput: $buildOutput}')"
+fi
+
+emit_result true "verify-build" "verify_build" 0 "All verification stages passed" "run_go_linter.sh && run_go_tests.sh && run_go_coverage.sh && go build -o <output> ./cmd/user-service" "$(details_json --arg buildTarget "$BUILD_TARGET" --arg buildOutput "$BUILD_OUTPUT" '{completedStages: ["run_go_linter", "run_go_tests", "run_go_coverage", "go-build"], buildTarget: $buildTarget, buildOutput: $buildOutput}')"

package/dist/executors/claude-summary-executor.js

@@ -1,31 +0,0 @@
-import { readFileSync } from "node:fs";
-import { requireArtifacts } from "../artifacts.js";
-import { claudeSummaryExecutorDefaultConfig } from "./configs/claude-summary-config.js";
-import { processExecutor } from "./process-executor.js";
-function resolveModel(config, env) {
-    return env[config.modelEnvVar]?.trim() || config.defaultModel;
-}
-export const claudeSummaryExecutor = {
-    kind: "claude-summary",
-    version: 1,
-    defaultConfig: claudeSummaryExecutorDefaultConfig,
-    async execute(context, input, config) {
-        const env = input.env ?? context.env;
-        const command = input.command ?? context.runtime.resolveCmd(config.defaultCommand, config.commandEnvVar);
-        const model = input.model?.trim() || resolveModel(config, env);
-        const argv = [command, "--model", model, config.promptFlag, `--allowedTools=${config.allowedTools}`, input.prompt];
-        const processInput = {
-            argv,
-            env,
-            label: `claude:${model}`,
-        };
-        const result = await processExecutor.execute(context, input.verbose === undefined ? processInput : { ...processInput, verbose: input.verbose }, processExecutor.defaultConfig);
-        requireArtifacts([input.outputFile], `Claude summary did not produce ${input.outputFile}.`);
-        return {
-            output: result.output,
-            artifactText: readFileSync(input.outputFile, "utf8").trim(),
-            command,
-            model,
-        };
-    },
-};

package/dist/executors/configs/claude-summary-config.js

@@ -1,8 +0,0 @@
-export const claudeSummaryExecutorDefaultConfig = {
-    commandEnvVar: "CLAUDE_BIN",
-    defaultCommand: "claude",
-    modelEnvVar: "CLAUDE_SUMMARY_MODEL",
-    defaultModel: "haiku",
-    promptFlag: "-p",
-    allowedTools: "Read,Write,Edit",
-};

package/dist/pipeline/flow-runner.js

@@ -1,13 +0,0 @@
-export async function runFlow(definition, context, params, options = {}) {
-    const steps = [];
-    for (const step of definition.steps) {
-        await options.onStepStart?.(step);
-        const result = await step.run(context, params);
-        await options.onStepComplete?.(step, result);
-        steps.push({
-            id: step.id,
-            result,
-        });
-    }
-    return { steps };
-}

package/dist/pipeline/flow-specs/test-fix.json

@@ -1,24 +0,0 @@
-{
-  "kind": "test-fix-flow",
-  "version": 1,
-  "phases": [
-    {
-      "id": "test-fix",
-      "steps": [
-        {
-          "id": "run_codex_test_fix",
-          "node": "codex-local-prompt",
-          "prompt": {
-            "templateRef": "test-fix",
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "format": "task-prompt"
-          },
-          "params": {
-            "labelText": { "const": "Running Codex test-fix mode locally" },
-            "model": { "const": "gpt-5.4" }
-          }
-        }
-      ]
-    }
-  ]
-}

package/dist/pipeline/flow-specs/test-linter-fix.json

@@ -1,24 +0,0 @@
-{
-  "kind": "test-linter-fix-flow",
-  "version": 1,
-  "phases": [
-    {
-      "id": "test-linter-fix",
-      "steps": [
-        {
-          "id": "run_codex_test_linter_fix",
-          "node": "codex-local-prompt",
-          "prompt": {
-            "templateRef": "test-linter-fix",
-            "extraPrompt": { "ref": "params.extraPrompt" },
-            "format": "task-prompt"
-          },
-          "params": {
-            "labelText": { "const": "Running Codex test-linter-fix mode locally" },
-            "model": { "const": "gpt-5.4" }
-          }
-        }
-      ]
-    }
-  ]
-}

package/dist/pipeline/flow-specs/test.json

@@ -1,19 +0,0 @@
-{
-  "kind": "test-flow",
-  "version": 1,
-  "phases": [
-    {
-      "id": "test",
-      "steps": [
-        {
-          "id": "verify_build",
-          "node": "verify-build",
-          "params": {
-            "dockerComposeFile": { "ref": "params.dockerComposeFile" },
-            "labelText": { "const": "Running build verification in isolated Docker" }
-          }
-        }
-      ]
-    }
-  ]
-}

package/dist/pipeline/flow-types.js

@@ -1 +0,0 @@
-export {};

package/dist/pipeline/flows/implement-flow.js

@@ -1,47 +0,0 @@
-import { runFlow } from "../flow-runner.js";
-import { runNode } from "../node-runner.js";
-import { codexLocalPromptNode } from "../nodes/codex-local-prompt-node.js";
-import { verifyBuildNode } from "../nodes/verify-build-node.js";
-export const implementFlowDefinition = {
-    kind: "implement-flow",
-    version: 1,
-    steps: [
-        {
-            id: "run_codex_implement",
-            async run(context, params) {
-                await runNode(codexLocalPromptNode, context, {
-                    prompt: params.prompt,
-                    labelText: "Running Codex implementation mode locally",
-                });
-                return { completed: true };
-            },
-        },
-        {
-            id: "verify_build_after_implement",
-            async run(context, params) {
-                if (!params.runFollowupVerify) {
-                    return {
-                        completed: true,
-                        metadata: { skipped: true },
-                    };
-                }
-                try {
-                    await runNode(verifyBuildNode, context, {
-                        dockerComposeFile: params.dockerComposeFile,
-                        labelText: "Running build verification in isolated Docker",
-                    });
-                }
-                catch (error) {
-                    if (params.onVerifyBuildFailure) {
-                        await params.onVerifyBuildFailure(String(error.output ?? ""));
-                    }
-                    throw error;
-                }
-                return { completed: true };
-            },
-        },
-    ],
-};
-export async function runImplementFlow(context, params) {
-    await runFlow(implementFlowDefinition, context, params);
-}

package/dist/pipeline/flows/plan-flow.js

@@ -1,42 +0,0 @@
-import { designFile, planArtifacts, planFile, qaFile } from "../../artifacts.js";
-import { PLAN_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
-import { runFlow } from "../flow-runner.js";
-import { runNode } from "../node-runner.js";
-import { jiraFetchNode } from "../nodes/jira-fetch-node.js";
-import { planCodexNode } from "../nodes/plan-codex-node.js";
-export const planFlowDefinition = {
-    kind: "plan-flow",
-    version: 1,
-    steps: [
-        {
-            id: "fetch_jira",
-            async run(context, params) {
-                await runNode(jiraFetchNode, context, {
-                    jiraApiUrl: params.jiraApiUrl,
-                    outputFile: params.jiraTaskFile,
-                });
-                return { completed: true };
-            },
-        },
-        {
-            id: "run_codex_plan",
-            async run(context, params) {
-                const prompt = formatPrompt(formatTemplate(PLAN_PROMPT_TEMPLATE, {
-                    jira_task_file: params.jiraTaskFile,
-                    design_file: designFile(params.taskKey),
-                    plan_file: planFile(params.taskKey),
-                    qa_file: qaFile(params.taskKey),
-                }), params.extraPrompt);
-                await runNode(planCodexNode, context, {
-                    prompt,
-                    command: params.codexCmd,
-                    requiredArtifacts: planArtifacts(params.taskKey),
-                });
-                return { completed: true };
-            },
-        },
-    ],
-};
-export async function runPlanFlow(context, params) {
-    await runFlow(planFlowDefinition, context, params);
-}

package/dist/pipeline/flows/review-fix-flow.js

@@ -1,62 +0,0 @@
-import { artifactFile, planArtifacts, requireArtifacts } from "../../artifacts.js";
-import { TaskRunnerError } from "../../errors.js";
-import { REVIEW_FIX_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
-import { runFlow } from "../flow-runner.js";
-import { runNode } from "../node-runner.js";
-import { codexLocalPromptNode } from "../nodes/codex-local-prompt-node.js";
-import { verifyBuildNode } from "../nodes/verify-build-node.js";
-export function createReviewFixFlowDefinition(iteration) {
-    return {
-        kind: "review-fix-flow",
-        version: 1,
-        steps: [
-            {
-                id: "run_codex_review_fix",
-                async run(stepContext, stepParams) {
-                    const reviewReplyFile = artifactFile("review-reply", stepParams.taskKey, iteration);
-                    const reviewFixFile = artifactFile("review-fix", stepParams.taskKey, iteration);
-                    const prompt = formatPrompt(formatTemplate(REVIEW_FIX_PROMPT_TEMPLATE, {
-                        review_reply_file: reviewReplyFile,
-                        items: stepParams.reviewFixPoints ?? "",
-                        review_fix_file: reviewFixFile,
-                    }), stepParams.extraPrompt);
-                    await runNode(codexLocalPromptNode, stepContext, {
-                        prompt,
-                        labelText: `Running Codex review-fix mode locally (iteration ${iteration})`,
-                        requiredArtifacts: stepContext.dryRun ? [] : [reviewFixFile],
-                        missingArtifactsMessage: "Review-fix mode did not produce the required review-fix artifact.",
-                    });
-                    return { completed: true, metadata: { iteration } };
-                },
-            },
-            {
-                id: "verify_build_after_review_fix",
-                async run(stepContext, stepParams) {
-                    if (!stepParams.runFollowupVerify) {
-                        return { completed: true, metadata: { skipped: true } };
-                    }
-                    try {
-                        await runNode(verifyBuildNode, stepContext, {
-                            dockerComposeFile: stepParams.dockerComposeFile,
-                            labelText: "Running build verification in isolated Docker",
-                        });
-                    }
-                    catch (error) {
-                        if (stepParams.onVerifyBuildFailure) {
-                            await stepParams.onVerifyBuildFailure(String(error.output ?? ""));
-                        }
-                        throw error;
-                    }
-                    return { completed: true };
-                },
-            },
-        ],
-    };
-}
-export async function runReviewFixFlow(context, params) {
-    requireArtifacts(planArtifacts(params.taskKey), "Review-fix mode requires plan artifacts from the planning phase.");
-    if (params.latestIteration === null) {
-        throw new TaskRunnerError(`Review-fix mode requires at least one review-reply-${params.taskKey}-N.md artifact.`);
-    }
-    await runFlow(createReviewFixFlowDefinition(params.latestIteration), context, params);
-}