fix: Critical fixes

Author: Azuyamat

cmd/pace/main.go

@@ -1,16 +1,16 @@
 package main
 
 import (
-	"fmt"
 	"os"
 
 	"github.com/azuyamat/pace/internal/command"
+	"github.com/azuyamat/pace/internal/logger"
 )
 
 func main() {
 	err := command.RootCommand.Run(os.Args[1:])
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		logger.Error("%s", err.Error())
 		os.Exit(1)
 	}
 }

config.pace

@@ -1,5 +1,29 @@
-task build {
-    command "go build -o bin/main ./..."
-    inputs ["**/*.go"]
-    outputs ["bin/main"]
+task test {
+	command "echo 'Test out pace'"
+	description "A simple test task"
+
+	dependencies ["extra", "extraJeff", "echoTime"]
+	working_dir "./internal/runner"
+	parallel true
 }
+
+task extra {
+	command "echo 'This is an extra task'"
+	description "An extra task for demonstration"
+	working_dir "./internal"
+	parallel true
+}
+
+task extraJeff {
+	command "echo 'This is another extra task'"
+	description "Another extra task for demonstration"
+	working_dir "./internal/runner"
+	parallel true
+}
+
+task echoTime {
+	command "date"
+	description "Echo the current date and time"
+	working_dir "./"
+	parallel false
+}

internal/command/run.go

@@ -5,7 +5,6 @@ import (
 
 	gear "github.com/azuyamat/gear/command"
 	"github.com/azuyamat/pace/internal/config"
-	"github.com/azuyamat/pace/internal/logger"
 	"github.com/azuyamat/pace/internal/runner"
 )
 
@@ -28,7 +27,6 @@ func runHandler(ctx *gear.Context, args gear.ValidatedArgs) error {
 
 	task, exists := config.GetTaskOrDefault(taskName)
 	if !exists {
-		logger.Error("Task '%s' not found", taskName)
 		return fmt.Errorf("task '%s' not found", taskName)
 	}
 

internal/config/config.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
@@ -90,13 +91,33 @@ func (cfg *Config) GetHook(name string) (models.Hook, bool) {
 }
 
 func processImports(cfg *Config, baseDir string) error {
+	visited := make(map[string]bool)
+	return processImportsRecursive(cfg, baseDir, visited)
+}
+
+func processImportsRecursive(cfg *Config, baseDir string, visited map[string]bool) error {
 	for _, importPath := range cfg.Imports {
 		fullPath := filepath.Join(baseDir, importPath)
+		absPath, err := filepath.Abs(fullPath)
+		if err != nil {
+			return fmt.Errorf("failed to resolve import path %q: %v", fullPath, err)
+		}
+
+		if visited[absPath] {
+			return fmt.Errorf("circular import detected: %q", absPath)
+		}
+
+		visited[absPath] = true
+
 		importedCfg, err := ParseFile(fullPath)
 		if err != nil {
 			return err
 		}
 
+		if err := processImportsRecursive(importedCfg, filepath.Dir(fullPath), visited); err != nil {
+			return err
+		}
+
 		importField(importedCfg.Tasks, cfg.Tasks)
 		importField(importedCfg.Hooks, cfg.Hooks)
 		importField(importedCfg.Constants, cfg.Constants)

internal/config/resolver.go

@@ -1,49 +1,52 @@
 package config
 
 import (
-	"fmt"
 	"os"
 	"regexp"
 	"strings"
+
+	"github.com/azuyamat/pace/internal/logger"
 )
 
 var varPattern = regexp.MustCompile(`\$\{([^}]+)\}`)
 
 type Resolver struct {
-	config *Config
+	config         *Config
+	unresolvedVars map[string]bool
 }
 
 func NewResolver(config *Config) *Resolver {
-	return &Resolver{config: config}
+	return &Resolver{
+		config:         config,
+		unresolvedVars: make(map[string]bool),
+	}
 }
 
-// ResolveString resolves variable references in a string
 func (r *Resolver) ResolveString(input string) string {
 	return varPattern.ReplaceAllStringFunc(input, func(match string) string {
-		// Extract variable name from ${VAR}
 		varName := match[2 : len(match)-1]
 
-		// Check in constants first
 		if value, exists := r.config.Constants[varName]; exists {
 			return value
 		}
 
-		// Check in globals
 		if value, exists := r.config.Globals[varName]; exists {
 			return value
 		}
 
-		// Check environment variables
 		if value := os.Getenv(varName); value != "" {
 			return value
 		}
 
-		// Return original if not found
+		if !r.unresolvedVars[varName] {
+			logger.Warning("Unresolved variable: ${%s}", varName)
+			r.unresolvedVars[varName] = true
+		}
+
 		return match
 	})
 }
 
-// ResolveStringSlice resolves variables in a slice of strings
 func (r *Resolver) ResolveStringSlice(slice []string) []string {
 	result := make([]string, len(slice))
 	for i, s := range slice {
@@ -111,40 +114,3 @@ func ExpandEnvVars(s string) string {
 
 	return result.String()
 }
-
-// EvaluateCondition evaluates simple conditional expressions
-func EvaluateCondition(condition string) (bool, error) {
-	condition = strings.TrimSpace(condition)
-
-	// Handle OS checks: OS == "windows" or OS == "linux"
-	if strings.Contains(condition, "OS") {
-		osPattern := regexp.MustCompile(`OS\s*==\s*"([^"]+)"`)
-		matches := osPattern.FindStringSubmatch(condition)
-		if len(matches) > 1 {
-			targetOS := strings.ToLower(matches[1])
-			currentOS := strings.ToLower(os.Getenv("GOOS"))
-			if currentOS == "" {
-				currentOS = "windows" // Default for this system
-			}
-			return currentOS == targetOS, nil
-		}
-	}
-
-	// Handle environment variable checks: ENV_VAR == "value"
-	envPattern := regexp.MustCompile(`([A-Z_][A-Z0-9_]*)\s*==\s*"([^"]+)"`)
-	matches := envPattern.FindStringSubmatch(condition)
-	if len(matches) > 2 {
-		envVar := matches[1]
-		expectedValue := matches[2]
-		actualValue := os.Getenv(envVar)
-		return actualValue == expectedValue, nil
-	}
-
-	// Handle boolean environment variables: ENV_VAR
-	if matched, _ := regexp.MatchString(`^[A-Z_][A-Z0-9_]*$`, condition); matched {
-		value := os.Getenv(condition)
-		return value != "" && value != "0" && strings.ToLower(value) != "false", nil
-	}
-
-	return false, fmt.Errorf("unable to evaluate condition: %s", condition)
-}

internal/logger/logger.go

@@ -107,6 +107,24 @@ func (l *Logger) Debug(format string, args ...interface{}) {
 	fmt.Printf("%s %s %s %s\n", l.timestamp(), badge, icon, coloredMsg)
 }
 
+func (l *Logger) TaskOutput(taskName string, format string, args ...interface{}) {
+	if !l.enabled || l.level > LevelInfo {
+		return
+	}
+	msg := fmt.Sprintf(format, args...)
+	taskBadge := ColorCyan.Wrap("[" + taskName + "]")
+	fmt.Printf("%s %s %s\n", l.timestamp(), taskBadge, ColorWhite.Wrap(msg))
+}
+
+func (l *Logger) TaskError(taskName string, format string, args ...interface{}) {
+	if !l.enabled || l.level > LevelInfo {
+		return
+	}
+	msg := fmt.Sprintf(format, args...)
+	taskBadge := ColorRed.Wrap("[" + taskName + "]")
+	fmt.Printf("%s %s %s\n", l.timestamp(), taskBadge, ColorRed.Bright().Wrap(msg))
+}
+
 func (l *Logger) Print(format string, args ...interface{}) {
 	msg := fmt.Sprintf(format, args...)
 	fmt.Println(msg)