MTime based Task Evaluation

[trulede]

Simplification:

MTime based change detection only.

Based on sources (existing) and targets (new). When no target is defined, the time of last task execution is retained in .task file.

Each task execution/call is tracked by a hash of all task fields (name, sources, dir ...). Hash is used as index in .task file.

run is replaced by simple force, at CLI and on task call.

Fine-grain control via preconditions/status.

[trulede]

idea:

package fingerprint

import (
	"os"
	"path/filepath"
	"time"

	"://github.com"
)

type TimestampChecker struct {
	tempDir string
	dry     bool
}

func NewTimestampChecker(tempDir string, dry bool) *TimestampChecker {
	return &TimestampChecker{
		tempDir: tempDir,
		dry:     dry,
	}
}

// IsUpToDate implements the Checker interface with minimal disk I/O and early exits
func (checker *TimestampChecker) IsUpToDate(t *ast.Task) (bool, error) {
	if len(t.Sources) == 0 {
		return false, nil
	}

	// 1. Resolve source paths
	sources, err := Globs(t.Dir, t.Sources)
	if err != nil {
		return false, err
	}
	if len(sources) == 0 {
		return false, nil
	}

	// 2. Find the newest modification time among all source files
	var maxSourceTime time.Time
	for _, file := range sources {
		info, err := os.Stat(file)
		if err != nil {
			if os.IsNotExist(err) {
				return false, nil // Missing source means outdated
			}
			return false, err
		}
		if info.ModTime().After(maxSourceTime) {
			maxSourceTime = info.ModTime()
		}
	}

	// 3. Process the tracking timestamp file first if no explicit targets exist
	timestampFile := checker.timestampFilePath(t)
	timestampInfo, statErr := os.Stat(timestampFile)
	
	hasExplicitGenerates := len(t.Generates) > 0

	if statErr == nil {
		// If tracking file exists and we have NO other output definitions,
		// we can make a definitive decision right now.
		if !hasExplicitGenerates {
			if maxSourceTime.After(timestampInfo.ModTime()) {
				// Outdated: refresh timestamp for next execution run
				if !checker.dry {
					if err := checker.writeTimestampFile(timestampFile); err != nil {
						return false, err
					}
				}
				return false, nil
			}
			return true, nil // Early Exit: System is completely up to date!
		}
	} else if os.IsNotExist(statErr) {
		// Tracking file missing and no targets exist -> definitely outdated
		if !hasExplicitGenerates {
			if !checker.dry {
				if err := checker.writeTimestampFile(timestampFile); err != nil {
					return false, err
				}
			}
			return false, nil
		}
	} else {
		return false, statErr
	}

	// 4. Interleaved Target Evaluation: Loop glob definitions and exit early on mismatch
	for _, g := range t.Generates {
		if g.Negate {
			continue
		}
		
		files, err := glob(t.Dir, g.Glob)
		if err != nil {
			if os.IsNotExist(err) {
				return false, nil // A glob base folder/file missing means outdated
			}
			return false, err
		}
		if len(files) == 0 {
			return false, nil // Missing target means outdated
		}

		// Interleave timestamp check per discovered file inside the glob match
		for _, file := range files {
			info, err := os.Stat(file)
			if err != nil {
				if os.IsNotExist(err) {
					return false, nil
				}
				return false, err
			}

			// CRITICAL EARLY EXIT: If a source file was modified AFTER this output was created,
			// the task is definitively outdated. Stop checking other files immediately.
			if maxSourceTime.After(info.ModTime()) {
				return false, nil 
			}
		}
	}

	// 5. Explicit targets are present. If we found a fallback timestamp cache file earlier,
	// ensure it's also newer than our newest source.
	if statErr == nil && maxSourceTime.After(timestampInfo.ModTime()) {
		return false, nil
	}

	// If we successfully survived every single target comparison, everything is up to date.
	return true, nil
}

func (checker *TimestampChecker) writeTimestampFile(path string) error {
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		return err
	}
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	return f.Close()
}

func (checker *TimestampChecker) timestampFilePath(t *ast.Task) string {
	return filepath.Join(checker.tempDir, t.Dir, "fingerprint.cache")
}

[trulede]

The challenge with this is the following:

• explicit: foo.c -> foo.o
• mapping: *.c -> *.o
• consolidate: *.c -> foo.o
• transient: *.c -> *.o -> foo.o
• implicit: *.c -> (target not defined)

which cannot really be expressed with simple glob patterns. What is really needed is some kind of relationship between sources and generates, especially in the mapping and transient cases. For a case where 5 .c files produce 4 .o files (one failed to build) that is an incomplete mapping. So this is a real problem of the current mechanism, which is somewhat lazy/incomplete.

I don't know the solution, other than Makefile does it correctly, so we should consider defining the transformation rather than separate lists of sources and generates.

A list of transformers ...

[trulede]

These are some good AI generated ideas:

version: '4'

tasks:
  compile-pages:
    # The matrix dynamically builds the execution context
    transforms:
      - match: src/docs/(.*)/(.*)\.md
        yield: public/html/$1/$2.html
    cmds:
      # $1 and $2 are extracted from the matched row file path
      - markdown-cli src/docs/$1/$2.md --output public/html/$1/$2.html

version: '4'

tasks:
  minify-assets:
    transforms:
      # {name} captures the filename without its directory path or extension
      - match: src/js/{name}.js
        yield: public/dist/{name}.min.js
    cmds:
      # The engine injects the token cleanly into the command execution string
      - esbuild src/js/{name}.js --bundle --minify --outfile=public/dist/{name}.min.js

version: '4'

tasks:
  build-styles:
    transforms:
      # Row 1: Uses a standard expanded tailwind configuration
      - match: src/css/main.css
        yield: public/css/main.css
        vars:  { mode: "expanded" }

      # Row 2: Overrides the local variable to force a compressed build
      - match: src/css/admin.css
        yield: public/css/admin.min.css
        vars:  { mode: "compressed" }
        
    cmds:
      # Uses Task's standard dot notation syntax for the local variable
      - sass src/css/{{.MATCH}} public/css/{{.YIELD}} --style={{.mode}}

version: '4'

tasks:
  concat-vendor:
    transforms:
      - match:
          - vendor/core/**/*.js
          - vendor/plugins/*.js
        yield: public/vendor-all.js
    cmds:
      - concat-cli --inputs {{.MATCH | join ","}} --output {{.YIELD}}