Files
archie/internal/domain/workflow/feasibility.go
T
sam 5c0efaceaf refactor(workflow): relocate Task/Status/Source and define workflow.Store (#754)
* 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
2026-09-07 00:39:26 +10:00

166 lines
5.9 KiB
Go

package workflow
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"time"
"github.com/samcharles93/archie-core/internal/agentexec"
)
// Feasibility is the feature-request workflow: assess the request
// against the project's direction, close it with reasons when it
// doesn't fit, otherwise produce a PRD, deliver it to Sam (issue
// comment + notify webhook), and hand the task to waiting_human. The
// daemon watches for Sam's reply and -- LLM-judged, not keyword-matched --
// requeues approved features under the implement workflow or closes
// rejected ones. Routed via the "feature" label.
func Feasibility() Workflow {
return Workflow{
Name: "feasibility",
Stages: []Stage{
StagePrepareWorktree(), // read-only stages still need the checkout
AgentStage{
Name: "assess",
Role: "planner",
ReadOnly: true,
CaptureTools: decideCaptureTools,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Assess whether this feature request fits the project %s.\n\n"+
"%s\n\n"+
"Read the repository's AGENT.md, ROADMAP.md, and README (whichever exist) plus "+
"enough code to judge scope and architectural fit. Then call the decide tool "+
"EXACTLY ONCE with fit=true or fit=false and your reasons, and afterwards call "+
"finish with status \"passed\" summarising the assessment.",
tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
calls := res.Captures["decide"]
if len(calls) != 1 {
return fmt.Errorf("assess stage called the decide tool %d times (want exactly once)", len(calls))
}
var captured struct {
Fit *bool `json:"fit"`
Reasons string `json:"reasons"`
}
if err := json.Unmarshal(calls[0], &captured); err != nil {
return fmt.Errorf("decode feasibility decision: %w", err)
}
if captured.Fit == nil {
return fmt.Errorf("assess stage decision has no boolean fit value")
}
if captured.Reasons == "" {
return fmt.Errorf("assess stage decision has no reasons")
}
tc.decision = &decision{Fit: *captured.Fit, Reasons: captured.Reasons}
if !tc.decision.Fit {
if tc.Task.IsForgeBacked() {
if err := tc.Forge.CloseIssue(context.Background(), tc.Task.Owner, tc.Task.Repo, tc.Task.IssueNumber, ""); err != nil {
return err
}
}
tc.Outcome = Outcome{Status: StatusClosedWontDo, Detail: tc.decision.Reasons}
}
return nil
},
}.Stage(),
AgentStage{
Name: "prd",
Role: "planner",
ReadOnly: true,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Write a PRD for this accepted feature request on %s.\n\n"+
"%s\n\n<assessment>\n%s\n</assessment>\n\n"+
"Explore the affected code surface, then call finish with status \"passed\" and the "+
"PRD as the summary: problem, proposed solution, files/components affected, "+
"acceptance criteria, explicit non-goals, and estimated diff size. It will be read "+
"by a human deciding whether to green-light implementation.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.decision.Reasons,
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.Task.Plan = res.Summary
return nil
},
}.Stage(),
// Persist the PRD and block on Sam. Messaging and the Web UI are
// the decision surfaces; the forge issue is not a chat log.
{Name: "deliver", Run: func(ctx context.Context, tc *TaskContext) error {
notify(ctx, tc, "feasibility_prd")
tc.Outcome = Outcome{Status: StatusWaitingHuman, Detail: "PRD delivered, awaiting go/no-go"}
return nil
}},
},
}
}
// decision is the assess stage's structured verdict.
type decision struct {
Fit bool `json:"fit"`
Reasons string `json:"reasons"`
}
// decideCaptureTools gives the assess agent a structured verdict tool. Its
// arguments cross the execution boundary as data and are applied by OnResult.
func decideCaptureTools(*TaskContext) []agentexec.CaptureTool {
params := json.RawMessage(`{
"type": "object",
"properties": {
"fit": {"type": "boolean", "description": "true: fits the project and is worth a PRD. false: close as won't-do."},
"reasons": {"type": "string", "description": "The rationale, written for the human who filed the request."}
},
"required": ["fit", "reasons"]
}`)
return []agentexec.CaptureTool{{
Name: "decide", Description: "Record the feasibility verdict. Call exactly once, before finish.",
Parameters: params, RequiredFields: []string{"fit", "reasons"},
NonEmptyStrings: []string{"reasons"}, BooleanFields: []string{"fit"}, MaxCalls: 1,
}}
}
// notify POSTs a JSON payload to the configured webhook (n8n turns it
// into an email). Best-effort: failures log, the issue comment is the
// authoritative channel.
func notify(ctx context.Context, tc *TaskContext, kind string) {
url := tc.Cfg.Notify.Webhook
if url == "" {
return
}
fields := map[string]any{
"type": kind, "repo": tc.Repo.FullName(), "task_id": tc.Task.ID,
"source": tc.Task.Source, "identity": tc.Task.Identity,
"title": tc.Task.Title, "prd": tc.Task.Plan,
}
if tc.Task.IsForgeBacked() {
fields["issue"] = tc.Task.IssueNumber
fields["issue_url"] = fmt.Sprintf("%s/%s/issues/%d",
tc.Cfg.Forge.Host, tc.Repo.FullName(), tc.Task.IssueNumber)
}
payload, _ := json.Marshal(fields)
reqCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, url, bytes.NewReader(payload))
if err != nil {
tc.Log.Warn("notify webhook request build failed", "err", err)
return
}
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
tc.Log.Warn("notify webhook failed", "err", err)
return
}
if err := resp.Body.Close(); err != nil {
tc.Log.Warn("close notify webhook response", "err", err)
}
}