feat: Concurrency

Author: chebread

README.md

@@ -1,4 +1,4 @@
-# lx: Controllable AI for Gophers!
+# lx: Controllable AI for Gophers
 `lx` restores the [joy of wrangling code](https://tidyfirst.substack.com/p/augmented-coding-beyond-the-vibes) by letting you define the forest, while AI plants the trees under your intentional command.
 
 ---
@@ -52,6 +52,12 @@ You drive the flow and the contract; `lx` uses runtime traces to fill in the fun
 Code for any target, from any host.
 With Build Tags support, lx bridges the gap between your development machine and your production environment.
 
+## Concurrency
+Time is the only non-renewable resource for developers.
+`lx` doesn't process functions sequentially.
+It utilizes an Asynchronous Worker Pool to generate code for multiple functions in parallel.
+Whether you have 5 functions or 50, the total execution time converges to the duration of the single slowest request, not the sum of them all.
+
 ---
 
 # Quick Start
@@ -223,7 +229,7 @@ lx -tags lx_mock .
 1. Injects spies into target functions (wraps returns with `lx.Spy(...)`)
 2. Runs `go run .` inside the target directory to capture real inputs and expected outputs
 3. Reverts the injected spies immediately (restores your source files)
-4. Generates and patches the function bodies based on the captured evidence
+4. Generates function bodies in parallel (Async) and patches them based on the captured evidence
 
 ## Useful flags (optional)
 

cmd/main.go

@@ -23,6 +23,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -75,7 +76,11 @@ type commandLLM struct {
 	args    []string // <-- [수정 2] 템플릿 저장용 필드 추가
 }
 
+var logMu sync.Mutex
+
 func main() {
+	startTime := time.Now()
+
 	var (
 		showVersion bool
 		opts        options
@@ -150,11 +155,42 @@ func main() {
 		return
 	}
 
+	// [수정] 비동기 실행을 위한 설정
+	var wg sync.WaitGroup
+	// 최대 동시 실행 수 제한 (예: 5개). 너무 많이 띄우면 API Rate Limit에 걸립니다.
+	semaphore := make(chan struct{}, 5)
+
+	// 파일별 쓰기 충돌 방지를 위한 Mutex 맵
+	fileLocks := make(map[string]*sync.Mutex)
+	for _, t := range targets {
+		if _, exists := fileLocks[t.FilePath]; !exists {
+			fileLocks[t.FilePath] = &sync.Mutex{}
+		}
+	}
+
 	for _, target := range targets {
-		processSingleTarget(opts, llm, cfg, target)
+		wg.Add(1)
+		// 고루틴 실행
+		go func(t TargetInfo) {
+			defer wg.Done()
+
+			// 세마포어 획득 (슬롯이 비을 때까지 대기)
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }() // 작업 완료 후 반납
+
+			// 해당 파일 전용 락 가져오기
+			fileMu := fileLocks[t.FilePath]
+
+			// 비동기 처리 함수 호출
+			processSingleTarget(opts, llm, cfg, t, fileMu)
+		}(target)
 	}
 
-	fmt.Println("[lx] All tasks completed")
+	// 모든 작업이 끝날 때까지 대기
+	wg.Wait()
+
+	elapsed := time.Since(startTime)
+	fmt.Printf("[lx] All tasks completed in %s\n", elapsed)
 }
 
 func setupSafeExit(backups map[string]fileBackup) {
@@ -697,15 +733,24 @@ func scanProjectForLx(root string) []TargetInfo {
 	return targets
 }
 
-func processSingleTarget(opts options, llm LLM, cfg *Config, target TargetInfo) {
+func processSingleTarget(opts options, llm LLM, cfg *Config, target TargetInfo, fileMu *sync.Mutex) {
 	displayPath := target.FilePath
 	taskName := fmt.Sprintf("[%s -> %s]", displayPath, target.FuncName)
+
+	logMu.Lock()
 	fmt.Printf("[lx] %s Generate code\n", taskName)
+	logMu.Unlock()
+
+	fileMu.Lock()
 
 	fset := token.NewFileSet()
+
 	node, err := parser.ParseFile(fset, target.FilePath, nil, parser.ParseComments)
 	if err != nil {
+		fileMu.Unlock()
+		logMu.Lock()
 		fmt.Printf("[lx] %s parse failed: %v\n", taskName, err)
+		logMu.Unlock()
 		return
 	}
 
@@ -717,14 +762,20 @@ func processSingleTarget(opts options, llm LLM, cfg *Config, target TargetInfo)
 		}
 		return true
 	})
+
 	if currentFn == nil || currentFn.Body == nil {
+		fileMu.Unlock()
+		logMu.Lock()
 		fmt.Printf("[lx] %s function not found or has no body\n", taskName)
+		logMu.Unlock()
 		return
 	}
 
 	signature := extractSignature(fset, currentFn)
-	prompt := truncateString(singleLine(target.Prompt), opts.maxPromptChars)
 
+	fileMu.Unlock()
+
+	prompt := truncateString(singleLine(target.Prompt), opts.maxPromptChars)
 	isVoid := currentFn.Type.Results == nil || len(currentFn.Type.Results.List) == 0
 
 	outputSection := ""
@@ -772,19 +823,26 @@ RULES:
 
 	generatedCode, err := llm.Generate(ctx, cfg.Model, systemPrompt)
 	if err != nil {
+		logMu.Lock()
 		fmt.Printf("[lx] %s code generation failed\n", taskName)
 		fmt.Printf("[lx] Error: %s\n", diagnoseLLMError(err))
+		logMu.Unlock()
 		return
 	}
 
 	cleaned := cleanAICode(generatedCode)
 	deps := extractDependencies(cleaned)
 
+	fileMu.Lock()
+	defer fileMu.Unlock()
+
 	if ok := applyCodeToFile(target.FilePath, currentFn, fset, prompt, cleaned); ok {
+		logMu.Lock()
 		fmt.Printf("[lx] %s complete\n", taskName)
 		if len(deps) > 0 {
 			fmt.Printf("[lx] %s deps (manual): %s\n", taskName, strings.Join(uniqueStrings(deps), ", "))
 		}
+		logMu.Unlock()
 	}
 }