Fingerprint Input Hashing Implementation Plan#

resolvers:
  environment:
    value: "staging"

workflow:
  actions:
    generate-config:
      provider: go-template
      sources:
        - "templates/config.yaml.tpl"
      generates:
        - "output/config.yaml"
      inputs:
        data:
          expr: "_.environment"

1. Check when: condition         --> skip with SkipReasonCondition if false
2. Fingerprint Phase 1 (files)   --> if stale, proceed to step 3
                                     if fresh, proceed to step 3 then check Phase 2
3. Resolve inputs
4. Fingerprint Phase 2 (inputs)  --> skip with SkipReasonUpToDate if up-to-date
5. Execute action
6. On success: record fingerprints (sources + generates + inputs)

// pkg/fingerprint/fingerprint.go

const (
    // ReasonInputsChanged indicates resolved action inputs have changed since last run.
    ReasonInputsChanged Reason = "inputs changed"
)

// pkg/fingerprint/fingerprint.go -- add to existing Result struct

// InputsHash is the SHA-256 hash of current resolved inputs.
InputsHash string

// PreviousInputsHash is the stored hash of inputs from last successful run.
PreviousInputsHash string

// pkg/fingerprint/hash.go

// HashInputs computes a deterministic SHA-256 hash over the resolved action
// inputs map. Uses json.Marshal which sorts map keys lexicographically.
// Returns empty string and nil error if inputs is nil or empty.
func HashInputs(inputs map[string]any) (string, error)

// pkg/fingerprint/state.go

// inputsKey returns the state entry key for an action's inputs fingerprint.
// Format: "__fingerprint:<actionName>:inputs"
func inputsKey(actionName string) string

// LoadInputsHash retrieves the previously stored inputs hash from state.
// Returns empty string if not found.
func LoadInputsHash(data *state.Data, actionName string) string

// SaveHashes stores the current fingerprint hashes into state data.
// Updated signature: now accepts inputsHash in addition to sources and generates.
func SaveHashes(data *state.Data, actionName, sourcesHash, generatesHash, inputsHash string)

// pkg/fingerprint/fingerprint.go

// CheckFiles performs Phase 1: compares source/generates file hashes against
// stored state. If Stale==true, the caller should execute the action without
// proceeding to Phase 2. If Stale==false, the caller should resolve inputs
// and call CheckInputs.
func (c *Checker) CheckFiles(ctx context.Context, actionName string,
    sources, generates []string, baseDir string) (*Result, error)

// CheckInputs performs Phase 2: compares resolved input hashes against stored
// state. Only call this when CheckFiles returned Stale==false (files match).
// resolvedInputs is the full map returned by resolveInputs().
func (c *Checker) CheckInputs(ctx context.Context, actionName string,
    resolvedInputs map[string]any) (*Result, error)

// pkg/fingerprint/fingerprint.go

// Record stores the current fingerprints (sources + generates + inputs) after
// a successful action. Call this after action execution to persist the new
// baseline.
func (c *Checker) Record(ctx context.Context, actionName string,
    sources, generates []string, baseDir string,
    resolvedInputs map[string]any) error

when check --> fingerprint Check() --> resolveInputs() --> execute --> Record()

// Phase 1: File-based fingerprint check (cheap, before input resolution)
var filesFresh bool
if e.fingerprintChecker != nil && !e.noCache && len(action.Sources) > 0 {
    fpResult, fpErr := e.fingerprintChecker.CheckFiles(ctx, actionName,
        action.Sources, action.Generates, e.cwd)
    if fpErr != nil {
        logger.FromContext(ctx).V(0).Info("fingerprint check failed, executing action",
            "action", actionName, "error", fpErr.Error())
    } else if !fpResult.Stale {
        filesFresh = true
    }
}

// Resolve inputs (always needed -- for execution and Phase 2 check)
resolvedInputs, err := e.resolveInputs(ctx, action, graph.AliasMap)
if err != nil { /* existing error handling */ }

// Phase 2: Input-based fingerprint check (only if files were fresh)
if filesFresh {
    fpResult, fpErr := e.fingerprintChecker.CheckInputs(ctx, actionName, resolvedInputs)
    if fpErr != nil {
        logger.FromContext(ctx).V(0).Info("fingerprint inputs check failed, executing action",
            "action", actionName, "error", fpErr.Error())
    } else if !fpResult.Stale {
        e.actionContext.MarkSkipped(actionName, SkipReasonUpToDate)
        if e.progressCallback != nil {
            e.progressCallback.OnActionSkipped(actionName, string(SkipReasonUpToDate))
        }
        return nil
    }
}

// ... continue to execute action ...

// After success: record with inputs
if e.fingerprintChecker != nil && len(action.Sources) > 0 {
    if recordErr := e.fingerprintChecker.Record(ctx, actionName,
        action.Sources, action.Generates, e.cwd, resolvedInputs); recordErr != nil {
        logger.FromContext(ctx).V(0).Info("fingerprint record failed",
            "action", actionName, "error", recordErr.Error())
    }
}