base-layer/commandkit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Retain PromptKit diagnostics after cancellation

Browse Source
This commit is contained in:
Eric Rakestraw
2026-10-12 01:55:08 +00:00
parent ec4eb9d3a6
commit c6b4a42287
3 changed files with 82 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
docs/roadmap/implementation.md
View File

@@ -1,6 +1,6 @@
# Implement PromptKit comparison and catalogs
Status: Stage 1 complete; remaining stages are planned.
Status: Stages 1–2 complete; remaining stages are planned.
## Scope and authority
@@ -154,6 +154,25 @@ warnings. Check ordinary headings and deferred-writer error propagation. Create
native diagnostic fixtures through public APIs; do not import upstream internals
or assert exact cancellation polling counts.
**Completion evidence (2026-10-12)**
- Refactored the private engine loader to collect inspection diagnostics before
checking cancellation observed after a successful load. Diagnostic headings
retain the ordinary scope form and can identify a comparison side. ConfigKit
load diagnostics and the original load error remain available.
- Added adapter coverage for post-load cancellation, ConfigKit load-error identity
and diagnostics, ordinary and comparison-side headings, and deferred-writer
error propagation. `GOTOOLCHAIN=local go test ./...` passed in
`integrations/ckprompt`.
- PromptKit v0.14.0 provides no public warning callback in engine configuration,
and its native configuration path emits no warnings. Therefore a successful
engine with inspection warnings cannot be constructed through the public API;
native warning retention across cancellation remains unexercised. The ordering
change directly retains any diagnostics if a later PromptKit version supplies
them. The selected integration evidence is otherwise complete.
- Full repository and final assembled-state validation remain assigned to
Stage 12.
## Stage 3: Add the bundled PromptKit configuration pair provider
**Outcome:** `ConfigScope` advertises Diff and supplies a native provider usable

29
integrations/ckprompt/adapters.go
View File

@@ -76,7 +76,7 @@ func ConfigScope[I, S any](load func(context.Context, ckconfig.Selection, I, S)
}
scope.Acquire = func(ctx context.Context, request ckconfig.Request, input I, state S) (commandkit.Acquired[ckconfig.View], error) {
_, inspection, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, load)
_, inspection, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, "", load)
if err != nil {
return commandkit.Acquired[ckconfig.View]{Diagnostics: diagnostics}, err
}
@@ -104,7 +104,7 @@ func FromEngine[I, S any](load func(context.Context, ckconfig.Selection, I, S) (
return Suite[I, S]{
InspectPrompt: func(ctx context.Context, request PromptRequest, input I, state S) (commandkit.Acquired[*promptkit.PromptInspection], error) {
engine, _, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, load)
engine, _, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, "", load)
if err != nil {
return commandkit.Acquired[*promptkit.PromptInspection]{Diagnostics: diagnostics}, err
}
@@ -112,7 +112,7 @@ func FromEngine[I, S any](load func(context.Context, ckconfig.Selection, I, S) (
return commandkit.Acquired[*promptkit.PromptInspection]{Value: inspection, Diagnostics: diagnostics}, err
},
InspectProfile: func(ctx context.Context, request ProfileRequest, input I, state S) (commandkit.Acquired[*promptkit.ProfileInspection], error) {
engine, _, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, load)
engine, _, diagnostics, err := loadPromptKitEngine(ctx, request.Selection, input, state, "", load)
if err != nil {
return commandkit.Acquired[*promptkit.ProfileInspection]{Diagnostics: diagnostics}, err
}
@@ -127,33 +127,34 @@ func loadPromptKitEngine[I, S any](
selection ckconfig.Selection,
input I,
state S,
side string,
load engineLoader[I, S],
) (*promptkit.Engine, promptkit.ConfigurationInspection, []commandkit.Diagnostic, error) {
engine, err := load(ctx, selection, input, state)
if err != nil {
var loadErr *configkit.LoadError
if errors.As(err, &loadErr) {
return nil, promptkit.ConfigurationInspection{}, promptKitDiagnostics("promptkit", loadErr.Sources(), loadErr.Diagnostics()), err
return nil, promptkit.ConfigurationInspection{}, promptKitDiagnostics("promptkit", side, loadErr.Sources(), loadErr.Diagnostics()), err
}
return nil, promptkit.ConfigurationInspection{}, nil, err
}
if engine == nil {
return nil, promptkit.ConfigurationInspection{}, nil, errors.New("PromptKit configuration loader returned a nil engine")
}
if ctx != nil {
if err := ctx.Err(); err != nil {
return nil, promptkit.ConfigurationInspection{}, nil, err
}
}
inspection, err := engine.InspectConfiguration()
if err != nil {
return nil, promptkit.ConfigurationInspection{}, nil, err
}
diagnostics := promptKitDiagnostics("promptkit", inspection.Sources(), inspection.Diagnostics())
diagnostics := promptKitDiagnostics("promptkit", side, inspection.Sources(), inspection.Diagnostics())
if ctx != nil {
if err := ctx.Err(); err != nil {
return nil, promptkit.ConfigurationInspection{}, diagnostics, err
}
}
return engine, inspection, diagnostics, nil
}
func promptKitDiagnostics(scope string, sources []configkit.SourceInfo, records []configkit.Diagnostic) []commandkit.Diagnostic {
func promptKitDiagnostics(scope, side string, sources []configkit.SourceInfo, records []configkit.Diagnostic) []commandkit.Diagnostic {
if len(records) == 0 {
return nil
}
@@ -177,7 +178,11 @@ func promptKitDiagnostics(scope string, sources []configkit.SourceInfo, records
return []commandkit.Diagnostic{{
Severity: severity,
Write: func(writer io.Writer) error {
if _, err := fmt.Fprintf(writer, "Configuration scope %s:\n", strconv.Quote(scope)); err != nil {
heading := "Configuration scope " + strconv.Quote(scope)
if side != "" {
heading += " (" + side + ")"
}
if _, err := fmt.Fprintf(writer, "%s:\n", heading); err != nil {
return err
}
if len(sources) > 0 {

48
integrations/ckprompt/adapters_test.go
View File

@@ -203,12 +203,48 @@ func TestAdapterAcquisitionPreservesLoadAndContextErrors(t *testing.T) {
}
}
func TestFromEngineRetainsConfigKitLoadDiagnostics(t *testing.T) {
_, loadErr := configkit.Load[map[string]any](configkit.Bytes("invalid PromptKit config", []byte("broken: [")))
if loadErr == nil {
t.Fatal("invalid configuration unexpectedly loaded")
}
suite := FromEngine[int, int](func(context.Context, ckconfig.Selection, int, int) (*promptkit.Engine, error) {
return nil, loadErr
})
acquired, err := suite.InspectProfile(context.Background(), ProfileRequest{ID: "default"}, 0, 0)
var retained *configkit.LoadError
if !errors.As(err, &retained) || retained != loadErr || len(acquired.Diagnostics) == 0 {
t.Fatalf("load failure = (%#v, %v), want original ConfigKit error and diagnostics", acquired, err)
}
if acquired.Diagnostics[0].Severity != commandkit.SeverityError {
t.Fatalf("load diagnostics = %#v, want error severity", acquired.Diagnostics)
}
}
func TestConfigScopeHonorsCancellationAfterLoad(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
engine := adapterEngine(t)
scope := ConfigScope(func(context.Context, ckconfig.Selection, int, int) (*promptkit.Engine, error) {
cancel()
return engine, nil
})
acquired, err := scope.Acquire(ctx, ckconfig.Request{Operation: ckconfig.Show}, 0, 0)
if !errors.Is(err, context.Canceled) || acquired.Value.Effective != nil {
t.Fatalf("cancelled scope acquisition = (%#v, %v), want cancellation and no value", acquired, err)
}
}
func TestPromptKitDiagnosticsRemainDeferredAndPropagateWriterErrors(t *testing.T) {
writeErr := errors.New("diagnostic writer failed")
diagnostics := promptKitDiagnostics("promptkit", []configkit.SourceInfo{{ID: "source"}}, []configkit.Diagnostic{{
sources := []configkit.SourceInfo{{ID: "source"}}
records := []configkit.Diagnostic{{
Severity: configkit.SeverityWarning,
Message: "safe warning",
}})
}}
diagnostics := promptKitDiagnostics("promptkit", "", sources, records)
if len(diagnostics) != 1 || diagnostics[0].Severity != commandkit.SeverityWarning {
t.Fatalf("diagnostics = %#v", diagnostics)
}
@@ -216,9 +252,15 @@ func TestPromptKitDiagnosticsRemainDeferredAndPropagateWriterErrors(t *testing.T
t.Fatalf("diagnostic write error = %v", err)
}
var output bytes.Buffer
if err := diagnostics[0].Write(&output); err != nil || !strings.Contains(output.String(), "safe warning") || !strings.Contains(output.String(), `"source"`) {
if err := diagnostics[0].Write(&output); err != nil || !strings.Contains(output.String(), `Configuration scope "promptkit":`) || !strings.Contains(output.String(), "safe warning") || !strings.Contains(output.String(), `"source"`) {
t.Fatalf("diagnostic text = %q, %v", output.String(), err)
}
sideDiagnostics := promptKitDiagnostics("promptkit", "left", sources, records)
output.Reset()
if err := sideDiagnostics[0].Write(&output); err != nil || !strings.Contains(output.String(), `Configuration scope "promptkit" (left):`) {
t.Fatalf("comparison-side diagnostic text = %q, %v", output.String(), err)
}
}
type failingDiagnosticWriter struct{ err error }