feat: add --dump-schema flag for debugging formatting issues

- Added DumpSchema bool field to FormatOptions struct
- Added --dump-schema flag to both BindFlags and BindPFlags functions
- Modified SchemaFormatter.FormatFiles to dump schema to stderr when flag is set
- Schema is dumped in YAML format after loading but before processing data files
- Added comprehensive tests to verify the feature works correctly
- Output goes to stderr to avoid interfering with normal stdout output

Author: moshloop

.gitignore

@@ -53,3 +53,7 @@ coverage.html
 .env
 .env.local
 test.*
+hack/
+out.*
+clicky-*
+test-*

ai/claude.go

@@ -14,12 +14,12 @@ import (
 
 // ClaudeOptions contains configuration for Claude API calls
 type ClaudeOptions struct {
-	Model            string
-	MaxTokens        int
-	Debug            bool
-	StrictMCPConfig  bool
-	OutputFormat     string
-	MaxConcurrent    int
+	Model           string
+	MaxTokens       int
+	Debug           bool
+	StrictMCPConfig bool
+	OutputFormat    string
+	MaxConcurrent   int
 }
 
 // ClaudeResponse represents the response from Claude CLI
@@ -49,7 +49,7 @@ func NewClaudeExecutor(options ClaudeOptions) *ClaudeExecutor {
 	if options.Debug {
 		tm.SetVerbose(true)
 	}
-	
+
 	return &ClaudeExecutor{
 		options:     options,
 		taskManager: tm,
@@ -63,40 +63,26 @@ func (ce *ClaudeExecutor) GetTaskManager() *clicky.TaskManager {
 
 // ExecutePrompt executes a single Claude prompt with progress tracking
 func (ce *ClaudeExecutor) ExecutePrompt(ctx context.Context, name string, prompt string) (*ClaudeResponse, error) {
-	task := ce.taskManager.Start(name, clicky.WithFunc(func(ctx flanksourceContext.Context, t *clicky.Task) error {
+	t := clicky.StartTask[*ClaudeResponse](name, func(ctx flanksourceContext.Context, t *clicky.Task) (*ClaudeResponse, error) {
 		t.Infof("Starting Claude API call")
 		t.SetProgress(10, 100)
-		
+
 		response, err := ce.executeClaudeCLI(ctx, prompt, t)
 		if err != nil {
 			t.Errorf("Claude API failed: %v", err)
-			return err
+			return nil, err
 		}
-		
+
 		t.SetProgress(100, 100)
 		t.Infof("Received response (%d tokens)", response.GetTotalTokens())
-		
+
 		// Store response in task context
-		t.SetStatus(fmt.Sprintf("%s (completed)", name))
-		return nil
-	}))
-	
-	// Wait for this specific task
-	for task.Status() == clicky.StatusPending || task.Status() == clicky.StatusRunning {
-		select {
-		case <-ctx.Done():
-			task.Cancel()
-			return nil, ctx.Err()
-		case <-time.After(100 * time.Millisecond):
-		}
-	}
-	
-	if err := task.Error(); err != nil {
-		return nil, err
-	}
-	
+		t.SetName(fmt.Sprintf("%s (completed)", name))
+		return response, nil
+	})
+
 	// Execute again to get the actual response (since we can't store it in the task)
-	return ce.executeClaudeCLI(ctx, prompt, nil)
+	return t.GetResult()
 }
 
 // ExecutePromptBatch executes multiple prompts in parallel with concurrency control
@@ -107,20 +93,19 @@ func (ce *ClaudeExecutor) ExecutePromptBatch(ctx context.Context, prompts map[st
 		response *ClaudeResponse
 		err      error
 	}, len(prompts))
-	
+
 	// Create tasks for all prompts
 	for name, prompt := range prompts {
 		taskName := name
-		taskPrompt := prompt
-		
-		ce.taskManager.Start(taskName, 
+
+		ce.taskManager.Start(taskName,
 			clicky.WithTimeout(5*time.Minute),
 			clicky.WithFunc(func(ctx flanksourceContext.Context, t *clicky.Task) error {
 				t.Infof("Processing prompt")
 				t.SetProgress(0, 100)
-				
-				response, err := ce.executeClaudeCLI(t.Context(), taskPrompt, t)
-				
+
+				response, err := ce.executeClaudeCLI(t.Context(), prompt, t)
+
 				resultsChan <- struct {
 					name     string
 					response *ClaudeResponse
@@ -130,18 +115,18 @@ func (ce *ClaudeExecutor) ExecutePromptBatch(ctx context.Context, prompts map[st
 					response: response,
 					err:      err,
 				}
-				
+
 				if err != nil {
 					t.Errorf("Failed: %v", err)
 					return err
 				}
-				
+
 				t.SetProgress(100, 100)
 				t.Infof("Completed (%d tokens)", response.GetTotalTokens())
 				return nil
 			}))
 	}
-	
+
 	// Collect results
 	go func() {
 		for i := 0; i < len(prompts); i++ {
@@ -156,55 +141,55 @@ func (ce *ClaudeExecutor) ExecutePromptBatch(ctx context.Context, prompts map[st
 			}
 		}
 	}()
-	
+
 	// Wait for all tasks to complete
 	exitCode := ce.taskManager.Wait()
 	if exitCode != 0 {
 		return results, fmt.Errorf("some tasks failed (exit code %d)", exitCode)
 	}
-	
+
 	return results, nil
 }
 
 // executeClaudeCLI executes the Claude CLI command
 func (ce *ClaudeExecutor) executeClaudeCLI(ctx context.Context, prompt string, task *clicky.Task) (*ClaudeResponse, error) {
 	args := []string{"-p"}
-	
+
 	if ce.options.Model != "" {
 		args = append(args, "--model", ce.options.Model)
 	}
-	
+
 	if ce.options.OutputFormat != "" {
 		args = append(args, "--output-format", ce.options.OutputFormat)
 	} else {
 		args = append(args, "--output-format", "json")
 	}
-	
+
 	if ce.options.StrictMCPConfig {
 		args = append(args, "--strict-mcp-config")
 	}
-	
+
 	args = append(args, prompt)
-	
+
 	if task != nil {
 		task.Infof("Executing: claude %s", strings.Join(args[:2], " "))
 		task.SetProgress(30, 100)
 	}
-	
+
 	cmd := exec.CommandContext(ctx, "claude", args...)
 	output, err := cmd.CombinedOutput()
-	
+
 	if task != nil {
 		task.SetProgress(80, 100)
 	}
-	
+
 	if err != nil {
 		if ctx.Err() != nil {
 			return nil, fmt.Errorf("claude CLI cancelled: %w", ctx.Err())
 		}
 		return nil, fmt.Errorf("claude CLI failed: %w\nOutput: %s", err, string(output))
 	}
-	
+
 	// Try to parse JSON response
 	var response ClaudeResponse
 	if err := json.Unmarshal(output, &response); err != nil {
@@ -214,11 +199,11 @@ func (ce *ClaudeExecutor) executeClaudeCLI(ctx context.Context, prompt string, t
 			Result: string(output),
 		}, nil
 	}
-	
+
 	if response.IsError {
 		return nil, fmt.Errorf("claude returned error: %s", response.Result)
 	}
-	
+
 	if task != nil && ce.options.Debug {
 		task.Infof("Token usage: input=%d, cache_creation=%d, cache_read=%d, output=%d",
 			response.Usage.InputTokens,
@@ -227,7 +212,7 @@ func (ce *ClaudeExecutor) executeClaudeCLI(ctx context.Context, prompt string, t
 			response.Usage.OutputTokens)
 		task.Infof("Cost: $%.6f USD", response.TotalCostUSD)
 	}
-	
+
 	return &response, nil
 }
 
@@ -241,4 +226,4 @@ func (r *ClaudeResponse) GetTotalTokens() int {
 // GetAllTokens returns all tokens including cache reads
 func (r *ClaudeResponse) GetAllTokens() int {
 	return r.GetTotalTokens() + r.Usage.CacheReadInputTokens
-}
+}

aliases.go

@@ -0,0 +1,83 @@
+package clicky
+
+import (
+	"fmt"
+
+	"github.com/flanksource/clicky/task"
+	flanksourceContext "github.com/flanksource/commons/context"
+)
+
+// Type aliases for backward compatibility
+type (
+	Task               = task.Task
+	TaskManager        = task.Manager
+	TaskGroup          = task.Group
+	TaskStatus         = task.Status
+	TaskOption         = task.Option
+	TaskFunc           = task.TaskFunc[any]
+	TaskResult         = task.TaskResult[any]
+	TypedTask          = task.TypedTask[any]
+	LogEntry           = task.LogEntry
+	RetryConfig        = task.RetryConfig
+	WaitResult         = task.WaitResult
+	Waitable           = task.Waitable
+	TaskManagerOptions = task.ManagerOptions
+)
+
+// Status constants
+const (
+	StatusPending   = task.StatusPending
+	StatusRunning   = task.StatusRunning
+	StatusSuccess   = task.StatusSuccess
+	StatusFailed    = task.StatusFailed
+	StatusWarning   = task.StatusWarning
+	StatusCancelled = task.StatusCancelled
+)
+
+// Function aliases for backward compatibility
+var (
+	NewTaskManager                = task.NewManager
+	NewTaskManagerWithConcurrency = task.NewManagerWithConcurrency
+	NewTaskManagerWithOptions     = task.NewManagerWithOptions
+	DefaultRetryConfig            = task.DefaultRetryConfig
+	DefaultTaskManagerOptions     = task.DefaultManagerOptions
+	WithTimeout                   = task.WithTimeout
+	WithTaskTimeout               = task.WithTaskTimeout
+	WithDependencies              = task.WithDependencies
+	WithFunc                      = task.WithFunc
+	WithModel                     = task.WithModel
+	WithPrompt                    = task.WithPrompt
+	WithRetryConfig               = task.WithRetryConfig
+	WithPriority                  = task.WithPriority
+	BindTaskManagerFlags          = task.BindManagerFlags
+	BindTaskManagerPFlags         = task.BindManagerPFlags
+)
+
+// StartWithResultTyped creates and starts tracking a new task with generic typed result handling
+func StartWithResultTyped[T any](tm *TaskManager, name string, taskFunc task.TaskFunc[T], opts ...TaskOption) *task.Task {
+	// Wrap the typed function to work with the existing interface{} system
+	wrappedFunc := func(ctx flanksourceContext.Context, task *task.Task) (interface{}, error) {
+		result, err := taskFunc(ctx, task)
+		return result, err
+	}
+	return tm.StartWithResult(name, wrappedFunc, opts...)
+}
+
+// GetResultTyped returns the stored result with type assertion
+func GetResultTyped[T any](t *Task) (T, error) {
+	result, err := t.GetResult()
+	var zero T
+	if err != nil {
+		return zero, err
+	}
+
+	if result == nil {
+		return zero, nil
+	}
+
+	if typedResult, ok := result.(T); ok {
+		return typedResult, nil
+	}
+
+	return zero, fmt.Errorf("result type mismatch: expected %T, got %T", zero, result)
+}