* refactor(workflow,store): relocate Task/Status/Source and define workflow.Store Move store.Task, store.Status*/store.Source*, and the 3-method workflow store interface out of internal/store into internal/domain/workflow as workflow.Task/workflow.Status/workflow.Source plus a consumer-owned workflow.Store, superseding store.WorkflowStore. internal/domain/workflow now imports zero internal/store symbols; internal/store persists the domain type instead (infrastructure depends on domain), and its Store satisfies workflow.Store. Updates every production and test caller of the relocated symbols across daemon, webui, gateway, agentworker, agenttransport/nats, storerpc, taskrun, and worktreerpc, and removes TestRecordDispatchViaExplicitTx per docs/prds/state-store-contract.md (rev. 2c) sections 4 and 12 step 2. Two workflow-package integration tests that exercise the real *store.Store move to an external workflow_test package (store_integration_test.go) to avoid a workflow(test)->store->workflow(prod) import cycle now that store depends on workflow. * no-mistakes(document): docs(state-store): mark §4.8 relocation done in state-store-contract
271 lines
9.3 KiB
Go
271 lines
9.3 KiB
Go
package workflow
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/gate"
|
|
"github.com/samcharles93/archie-core/internal/gate/gateeval"
|
|
)
|
|
|
|
// Shared step library. Every workflow composes these; workflow-specific
|
|
// stages live next to their workflow definition.
|
|
|
|
// StagePrepareWorktree clones the repo fresh and checks out the task
|
|
// branch. Skips if the daemon already prepared the worktree (Docker
|
|
// containers require the tree before acquire).
|
|
func StagePrepareWorktree() Stage {
|
|
return Stage{Name: "prepare", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
dir, branch, err := tc.Trees.Prepare(ctx, tc.Task.Owner, tc.Task.Repo, tc.Repo.BaseBranch(), tc.Task.IssueNumber, tc.Task.Title, tc.Task.Body, tc.Task.Labels)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tc.Dir, tc.Branch = dir, branch
|
|
tc.Task.Branch = branch
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// StageCommit commits everything in the worktree without pushing --
|
|
// used mid-workflow so a PR tells its story in multiple commits (TDD:
|
|
// failing tests first, fix second). An empty tree parks.
|
|
func StageCommit(name string, message func(*TaskContext) string) Stage {
|
|
return Stage{Name: name, Run: func(ctx context.Context, tc *TaskContext) error {
|
|
changed, err := tc.Trees.CommitAll(ctx, tc.Dir, message(tc))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !changed {
|
|
return fmt.Errorf("worktree has no changes to commit")
|
|
}
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// StageCommitPush commits everything in the worktree and pushes the
|
|
// branch. When the builder completed with no changes (BuildNoChanges is
|
|
// set), the issue is already resolved -- close it with a comment instead
|
|
// of erroring on an empty tree.
|
|
//
|
|
// When StageBaselineGate already committed a real fix (BaselineFixed) and
|
|
// the build stage made nothing further, the worktree has no *new*
|
|
// uncommitted changes -- CommitAll correctly reports changed=false -- but
|
|
// there is still a real, gate-verified commit sitting on the branch that
|
|
// must reach a PR rather than being discarded with the rest of an
|
|
// abandoned worktree. Push runs regardless of changed in that case.
|
|
func StageCommitPush(message func(*TaskContext) string) Stage {
|
|
return Stage{Name: "commit-push", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
if tc.BuildNoChanges {
|
|
return closeNoChangesIssue(ctx, tc)
|
|
}
|
|
changed, err := tc.Trees.CommitAll(ctx, tc.Dir, message(tc))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !changed && !tc.BaselineFixed {
|
|
return fmt.Errorf("worktree has no changes to commit")
|
|
}
|
|
return tc.Trees.Push(ctx, tc.Dir, tc.Branch)
|
|
}}
|
|
}
|
|
|
|
func closeNoChangesIssue(ctx context.Context, tc *TaskContext) error {
|
|
if !tc.Task.IsForgeBacked() {
|
|
tc.Outcome = Outcome{Status: StatusMerged, Detail: "completed -- no changes required"}
|
|
return nil
|
|
}
|
|
if err := tc.Forge.CloseIssue(ctx, tc.Task.Owner, tc.Task.Repo, tc.Task.IssueNumber, ""); err != nil {
|
|
return err
|
|
}
|
|
tc.Outcome = Outcome{Status: StatusMerged, Detail: "completed -- no changes required"}
|
|
return nil
|
|
}
|
|
|
|
// StageDiffCap parks tasks whose diff exceeds the configured line cap --
|
|
// oversized changes need human pre-approval, not an auto-opened PR.
|
|
func StageDiffCap() Stage {
|
|
return Stage{Name: "diff-cap", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
if tc.Cfg.DiffCapLines <= 0 {
|
|
return nil
|
|
}
|
|
lines, err := tc.Trees.ChangedLines(ctx, tc.Dir, tc.Repo.BaseBranch())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if lines > tc.Cfg.DiffCapLines {
|
|
tc.Outcome = Outcome{
|
|
Status: StatusParked,
|
|
Detail: fmt.Sprintf("diff is %d changed lines (cap %d) -- split the issue or approve manually", lines, tc.Cfg.DiffCapLines),
|
|
}
|
|
}
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// StageRepoStages runs every custom stage the repo defines under
|
|
// .archie/stages/*.go (Yaegi-interpreted via TaskContext.CustomStages),
|
|
// in the order the loader returns them -- a no-op when no loader is wired
|
|
// up or the repo defines none. A custom stage that sets tc.Outcome ends
|
|
// the workflow there, same as any built-in stage.
|
|
func StageRepoStages() Stage {
|
|
return Stage{Name: "repo-stages", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
if tc.CustomStages == nil {
|
|
return nil
|
|
}
|
|
stages, err := tc.CustomStages(tc.Dir)
|
|
if err != nil {
|
|
return fmt.Errorf("repo stages: %w", err)
|
|
}
|
|
for _, s := range stages {
|
|
tc.Log.Info("repo stage starting", "stage", s.Name)
|
|
if err := s.Run(ctx, tc); err != nil {
|
|
return fmt.Errorf("repo stage %s: %w", s.Name, err)
|
|
}
|
|
if tc.Outcome.Status != "" {
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// StageYaegiGate evaluates the repo's optional .archie/gate.go -- a
|
|
// Yaegi-interpreted Go file inspecting the committed diff for
|
|
// project-specific rules shell gate commands can't express (AST checks,
|
|
// diff scanning). A missing script is a no-op. Error-level findings
|
|
// park the task; warn-level findings are logged only.
|
|
func StageYaegiGate() Stage {
|
|
return Stage{Name: "custom-gate", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
base := tc.Repo.BaseBranch()
|
|
diff, err := tc.Trees.Diff(ctx, tc.Dir, base)
|
|
if err != nil {
|
|
return fmt.Errorf("custom gate: diff against %s: %w", base, err)
|
|
}
|
|
files, err := tc.Trees.ChangedFiles(ctx, tc.Dir, base)
|
|
if err != nil {
|
|
return fmt.Errorf("custom gate: changed files against %s: %w", base, err)
|
|
}
|
|
|
|
findings, err := gateeval.Evaluate(gate.GateContext{
|
|
Diff: diff,
|
|
ChangedFiles: files,
|
|
Dir: tc.Dir,
|
|
BaseRef: "origin/" + base,
|
|
Repo: tc.Repo.FullName(),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("custom gate: %w", err)
|
|
}
|
|
|
|
var blocking []string
|
|
for _, f := range findings {
|
|
loc := f.File
|
|
if f.Line > 0 {
|
|
loc = fmt.Sprintf("%s:%d", f.File, f.Line)
|
|
}
|
|
msg := strings.TrimSpace(loc + ": " + f.Message)
|
|
if f.Level == "error" {
|
|
blocking = append(blocking, msg)
|
|
}
|
|
tc.Log.Info("custom gate finding", "level", f.Level, "file", f.File, "line", f.Line, "message", f.Message)
|
|
}
|
|
if len(blocking) > 0 {
|
|
return fmt.Errorf("custom gate: %s", strings.Join(blocking, "; "))
|
|
}
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// OpenPR opens the task's pull request, records its number, and sets
|
|
// the terminal pr_open outcome. Stages that need to act after the PR
|
|
// exists (e.g. posting evidence comments) call this and then do so in
|
|
// the same stage -- the engine stops at the first stage with an outcome.
|
|
func OpenPR(ctx context.Context, tc *TaskContext, body string) error {
|
|
t := tc.Task
|
|
title := fmt.Sprintf("%s (archie)", t.Title)
|
|
if t.IsForgeBacked() {
|
|
// Best-effort. The link is cosmetic -- it puts the branch in the
|
|
// issue's sidebar on Gitea and does nothing on GitHub -- so failing
|
|
// the stage on it meant the pull request, the entire point of the
|
|
// run, was never opened and the task parked. A retry then re-links
|
|
// the same branch, which Gitea answers with a conflict, so every
|
|
// retry parked again.
|
|
if err := tc.Forge.LinkBranch(ctx, t.Owner, t.Repo, t.IssueNumber, tc.Branch); err != nil {
|
|
if tc.Log != nil {
|
|
tc.Log.Warn("link branch to issue failed; opening the PR anyway",
|
|
"repo", t.Owner+"/"+t.Repo, "issue", t.IssueNumber,
|
|
"branch", tc.Branch, "err", err)
|
|
}
|
|
}
|
|
}
|
|
num, err := tc.Forge.CreatePR(ctx, t.Owner, t.Repo, title, tc.Branch, tc.Repo.BaseBranch(), body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.PRNumber = num
|
|
tc.Outcome = Outcome{Status: StatusPROpen, Detail: fmt.Sprintf("PR #%d", num)}
|
|
return nil
|
|
}
|
|
|
|
// StageOpenPR opens the pull request with the given body and records it.
|
|
func StageOpenPR(body func(*TaskContext) string) Stage {
|
|
return Stage{Name: "open-pr", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
return OpenPR(ctx, tc, body(tc))
|
|
}}
|
|
}
|
|
|
|
func taskPromptBlock(task *Task) string {
|
|
if task.IsForgeBacked() {
|
|
return fmt.Sprintf("<issue number=%d>\n# %s\n\n%s\n</issue>",
|
|
task.IssueNumber, task.Title, task.Body)
|
|
}
|
|
return fmt.Sprintf("<task source=\"chat\">\n# %s\n\n%s\n</task>", task.Title, task.Body)
|
|
}
|
|
|
|
func taskKind(task *Task) string {
|
|
if task.IsForgeBacked() {
|
|
return "GitHub issue"
|
|
}
|
|
return "chat-originated task"
|
|
}
|
|
|
|
func commitIssueReference(verb string, task *Task) string {
|
|
if !task.IsForgeBacked() {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf("\n\n%s #%d", verb, task.IssueNumber)
|
|
}
|
|
|
|
// Bootstrap is the deterministic no-LLM workflow that proves the
|
|
// plumbing: it adds a marker file and opens a PR referencing the issue.
|
|
// It stays registered as a diagnostics workflow (label a test issue and
|
|
// you exercise invites, clone, push, and PR mechanics end to end).
|
|
func Bootstrap() Workflow {
|
|
return Workflow{
|
|
Name: "bootstrap",
|
|
Stages: []Stage{
|
|
StagePrepareWorktree(),
|
|
{Name: "apply", Run: func(ctx context.Context, tc *TaskContext) error {
|
|
dir := filepath.Join(tc.Dir, ".archie")
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
return err
|
|
}
|
|
content := fmt.Sprintf("# archie bootstrap\n\n%s\nTime: %s\n\nThis file proves the archie pipeline (queue → worktree → push → PR) works for this repository.\n",
|
|
taskPromptBlock(tc.Task), time.Now().UTC().Format(time.RFC3339))
|
|
return os.WriteFile(filepath.Join(dir, "bootstrap.md"), []byte(content), 0o644)
|
|
}},
|
|
StageCommitPush(func(tc *TaskContext) string {
|
|
return "chore: archie bootstrap marker" + commitIssueReference("Refs", tc.Task)
|
|
}),
|
|
StageDiffCap(),
|
|
StageOpenPR(func(tc *TaskContext) string {
|
|
return "Deterministic bootstrap PR from archie's plumbing walk-through."
|
|
}),
|
|
},
|
|
}
|
|
}
|