c9b904186a
Bring the packaged starters and the pipelines skill up to the guidelines the project now works to. Templates: - task and three-stage now end in a committer stage that stages the union of the runner's captured input.server_changed_files and the producer's declared changed_files, runs the repository's checks, commits locally and never pushes; their producers no longer commit. - Every model/agent prompt states the line-oriented result contract (outcome on the first non-empty line, "# output" JSON map, other "# <heading>" sections kept verbatim as evidence) and an "# evidence" section for exact commands and results, with proportionate verification and no fabricated checks. - Stages that can write save their reports, logs and screenshots into the runtime artifacts directory. - Remove the summary starter: a tool-free single-prompt text transform with no repository interaction, artifact or commit is a format demonstration, not a reusable workflow. No starter invents a pretend approval stage; a decision point is a type=human stage. Skill: - references/format.md gains a Result format section (line form, legacy JSON precedence, result_parse, raw-output.md, artifacts) and a Committer stages section with the pre-commit checklist; the role-split and envelope notes mention the line form and the committer. - orchestration.md points at the checklist and records that a genuine gate is a human stage; operations.md and the SKILL.md index drop the removed starter and name the result format and committer. No new reference, so the managed inventory is unchanged. Docs/tests: examples/README, README, docs/cli, docs/first-version-testing, the CLI help example and the smoke script track the four starters; catalog, tool-role, server, tui and pipeline tests are updated, with a new test pinning the committer ending and server-captured change set. Commands run: go build ./...; go vet ./...; go test ./...; python3 -m unittest discover -s scripts -p 'test_*.py'; python3 scripts/smoke-first-install.py. All passed. Templates inspected through an isolated CLI server (pipelines templates; pipelines template KEY --source). No server, service or device was restarted, and nothing was pushed.
210 lines
6.5 KiB
Go
210 lines
6.5 KiB
Go
package examples_test
|
|
|
|
import (
|
|
"os"
|
|
"slices"
|
|
"testing"
|
|
|
|
"git.a-wan.net/alan/pipelines/examples"
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/stage"
|
|
)
|
|
|
|
func TestReadmeThreeStageExampleIsValid(t *testing.T) {
|
|
source, err := os.ReadFile("three-stage.md")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
graph, err := pipeline.Parse(string(source))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(graph.Stages) != 4 || graph.Settings != nil {
|
|
t.Fatal("example must be manual-only and four stages")
|
|
}
|
|
}
|
|
|
|
func TestCatalogContainsValidUnpublishedTemplates(t *testing.T) {
|
|
items := examples.Catalog()
|
|
if len(items) != 4 {
|
|
t.Fatal("unexpected catalog size", len(items))
|
|
}
|
|
seen := map[string]bool{}
|
|
wantStages := map[string]int{"task": 2, "review": 1, "research": 2, "three-stage": 4}
|
|
for _, item := range items {
|
|
if seen[item.Key] || item.Description == "" || item.Name == "" {
|
|
t.Fatal("invalid template metadata", item.Key)
|
|
}
|
|
seen[item.Key] = true
|
|
graph, err := pipeline.Parse(item.Source)
|
|
if err != nil {
|
|
t.Fatal(item.Key, err)
|
|
}
|
|
if (graph.Settings != nil) != item.Scheduled {
|
|
t.Fatal("missing schedule warning", item.Key)
|
|
}
|
|
if graph.Settings != nil || len(graph.Stages) > 4 {
|
|
t.Fatal("starters must be small and manual-only", item.Key)
|
|
}
|
|
if len(graph.Stages) != wantStages[item.Key] {
|
|
t.Fatal("unexpected/non-generic catalog entry", item.Key)
|
|
}
|
|
}
|
|
}
|
|
|
|
// parsedCatalog parses every bundled starter once for the role/route assertions.
|
|
func parsedCatalog(t *testing.T) map[string]pipeline.Graph {
|
|
t.Helper()
|
|
parsed := map[string]pipeline.Graph{}
|
|
for _, item := range examples.Catalog() {
|
|
graph, err := pipeline.Parse(item.Source)
|
|
if err != nil {
|
|
t.Fatal(item.Key, err)
|
|
}
|
|
parsed[item.Key] = graph
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
func stageTools(t *testing.T, graph pipeline.Graph, key string) ([]string, bool) {
|
|
t.Helper()
|
|
for _, s := range graph.Stages {
|
|
if s.Key != key {
|
|
continue
|
|
}
|
|
tools, explicit, err := stage.ToolNames(pipeline.StageDefinition(s))
|
|
if err != nil {
|
|
t.Fatalf("stage %s: %v", key, err)
|
|
}
|
|
sorted := slices.Clone(tools)
|
|
slices.Sort(sorted)
|
|
return sorted, explicit
|
|
}
|
|
t.Fatalf("stage %s not found", key)
|
|
return nil, false
|
|
}
|
|
|
|
// starterTools is the expected explicit role allowlist per template and stage.
|
|
// Every bundled starter declares a tools block; an empty list is the intentional
|
|
// deny-all tool-free role.
|
|
var starterTools = map[string]map[string][]string{
|
|
"task": {
|
|
"worker": {"read", "glob", "grep", "edit", "shell", "websearch", "webfetch"},
|
|
"committer": {"read", "glob", "grep", "shell"},
|
|
},
|
|
"review": {"review": {"read", "glob", "grep", "websearch", "webfetch"}},
|
|
"research": {
|
|
"research": {"websearch", "webfetch"},
|
|
"report": {},
|
|
},
|
|
"three-stage": {
|
|
"planner": {"read", "glob", "grep", "websearch", "webfetch"},
|
|
"implementer": {"read", "glob", "grep", "edit", "shell"},
|
|
"reviewer": {"read", "glob", "grep", "shell", "websearch", "webfetch"},
|
|
"committer": {"read", "glob", "grep", "shell"},
|
|
},
|
|
}
|
|
|
|
func TestStarterRoleToolRestrictions(t *testing.T) {
|
|
parsed := parsedCatalog(t)
|
|
for key, stages := range starterTools {
|
|
graph, ok := parsed[key]
|
|
if !ok {
|
|
t.Fatalf("catalog entry %s missing", key)
|
|
}
|
|
for stageKey, want := range stages {
|
|
tools, explicit := stageTools(t, graph, stageKey)
|
|
if !explicit {
|
|
t.Fatalf("%s/%s must declare an explicit tools block", key, stageKey)
|
|
}
|
|
sortedWant := slices.Clone(want)
|
|
slices.Sort(sortedWant)
|
|
if !slices.Equal(tools, sortedWant) {
|
|
t.Fatalf("%s/%s tools = %v, want %v", key, stageKey, tools, sortedWant)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestThreeStagePlannerBlockedRoute(t *testing.T) {
|
|
graph := parsedCatalog(t)["three-stage"]
|
|
for _, s := range graph.Stages {
|
|
if s.Key == "planner" {
|
|
if got := s.Edges["blocked"]; got != protocol.FailureEnd {
|
|
t.Fatalf("planner blocked route = %q, want %q", got, protocol.FailureEnd)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestThreeStageReviewerMemoryKeepsPlannerAcceptance(t *testing.T) {
|
|
graph := parsedCatalog(t)["three-stage"]
|
|
var reviewer protocol.Stage
|
|
for _, s := range graph.Stages {
|
|
if s.Key == "reviewer" {
|
|
reviewer = s
|
|
}
|
|
}
|
|
if reviewer.Key == "" {
|
|
t.Fatal("three-stage reviewer stage missing")
|
|
}
|
|
plannerOwned := map[string]string{
|
|
"plan": "planner.plan",
|
|
"design": "planner.design",
|
|
"reuse_targets": "planner.reuse_targets",
|
|
"acceptance_checks": "planner.acceptance_checks",
|
|
"research": "planner.research",
|
|
}
|
|
for alias, reference := range plannerOwned {
|
|
if got := reviewer.Memory[alias]; got != reference {
|
|
t.Fatalf("reviewer memory %s = %q, want %q", alias, got, reference)
|
|
}
|
|
}
|
|
if got := reviewer.Memory["task"]; got != "input.prompt" {
|
|
t.Fatalf("reviewer must receive the original task, got %q", got)
|
|
}
|
|
for alias, want := range map[string]string{
|
|
"changed_files": "implementer.changed_files",
|
|
"implementation_summary": "implementer.implementation_summary",
|
|
"evidence": "implementer.evidence?",
|
|
} {
|
|
if got := reviewer.Memory[alias]; got != want {
|
|
t.Fatalf("reviewer memory %s = %q, want %q", alias, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestWorkProducingStartersEndInACommitter pins the guideline that a workflow
|
|
// which changes the repository commits locally through its final committer stage,
|
|
// staging the server-captured change set rather than only a model's declaration.
|
|
func TestWorkProducingStartersEndInACommitter(t *testing.T) {
|
|
for _, tc := range []struct{ key, producer string }{
|
|
{"task", "worker"},
|
|
{"three-stage", "implementer"},
|
|
} {
|
|
graph := parsedCatalog(t)[tc.key]
|
|
last := graph.Stages[len(graph.Stages)-1]
|
|
if last.Key != "committer" {
|
|
t.Fatalf("%s must end in a committer stage, got %q", tc.key, last.Key)
|
|
}
|
|
if got := last.Edges["success"]; got != protocol.SuccessEnd {
|
|
t.Fatalf("%s committer success route = %q, want %q", tc.key, got, protocol.SuccessEnd)
|
|
}
|
|
if got := last.Memory["server_changed_files"]; got != "input.server_changed_files" {
|
|
t.Fatalf("%s committer must select input.server_changed_files, got %q", tc.key, got)
|
|
}
|
|
if got := last.Memory["changed_files"]; got != tc.producer+".changed_files" {
|
|
t.Fatalf("%s committer changed_files = %q, want %q", tc.key, got, tc.producer+".changed_files")
|
|
}
|
|
// The producer hands its work on rather than ending the run itself.
|
|
for _, s := range graph.Stages {
|
|
if s.Key == tc.producer {
|
|
if protocol.IsTerminal(s.Edges["success"]) {
|
|
t.Fatalf("%s/%s must hand success to a later stage, not %q", tc.key, tc.producer, s.Edges["success"])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|