#113 reverted

Author: yegor256

.golangci.yml

@@ -18,8 +18,6 @@ linters:
     - unused
     - goconst
   settings:
-     staticcheck:
-       checks: ["all", "-ST1005"]
      goconst:
        min-len: 2
        min-occurrences: 2

internal/brain/deepseek.go

@@ -69,7 +69,7 @@ func (d *deepSeek) send(system, user string) (answer string, err error) {
 	}
 	data, err := json.Marshal(body)
 	if err != nil {
-		return "", fmt.Errorf("Error marshaling request body: %w", err)
+		return "", fmt.Errorf("error marshaling request body: %w", err)
 	}
 	req, err := http.NewRequest("POST", d.url, bytes.NewBuffer(data))
 	if err != nil {
@@ -79,23 +79,23 @@ func (d *deepSeek) send(system, user string) (answer string, err error) {
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", d.token))
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("Error making request to deepseek api: %w", err)
+		return "", fmt.Errorf("error making request to deepseek api: %w", err)
 	}
 	defer func() {
 		if cerr := resp.Body.Close(); cerr != nil {
-			err = fmt.Errorf("Error closing response body: %w", cerr)
+			err = fmt.Errorf("error closing response body: %w", cerr)
 		}
 	}()
 	if resp.StatusCode != 200 {
 		content, _ := io.ReadAll(resp.Body)
-		return "", fmt.Errorf("API error: %s", content)
+		return "", fmt.Errorf("api error: %s", content)
 	}
 	var parsed deepseekResp
 	if err = json.NewDecoder(resp.Body).Decode(&parsed); err != nil {
-		return "", fmt.Errorf("Error decoding response: %w", err)
+		return "", fmt.Errorf("error decoding response: %w", err)
 	}
 	if len(parsed.Choices) == 0 {
-		return "", errors.New("No choices in response")
+		return "", errors.New("no choices in response")
 	}
 	answer = parsed.Choices[0].Message.Content
 	return answer, err

internal/brain/openai.go

@@ -71,7 +71,7 @@ func (o *openAI) send(system, user string) (answer string, err error) {
 	req.Header.Set("Authorization", "Bearer "+o.token)
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("API request failed: %w", err)
+		return "", fmt.Errorf("api request failed: %w", err)
 	}
 	defer func() {
 		if cerr := resp.Body.Close(); cerr != nil {
@@ -80,7 +80,7 @@ func (o *openAI) send(system, user string) (answer string, err error) {
 	}()
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(resp.Body)
-		return "", fmt.Errorf("API error: %s", body)
+		return "", fmt.Errorf("api error: %s", body)
 	}
 	var response openaiResp
 	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {

internal/client/refrax_client.go

@@ -38,7 +38,7 @@ func NewRefraxClient(params *Params) *RefraxClient {
 func Refactor(params *Params) (domain.Project, error) {
 	proj, err := proj(*params)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create project from params: %w", err)
+		return nil, fmt.Errorf("failed to create project from params: %w", err)
 	}
 	return NewRefraxClient(params).Refactor(proj)
 }
@@ -48,10 +48,10 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	log.Debug("Starting refactoring for project %s", proj)
 	classes, err := proj.Classes()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to get classes from project %s: %w", proj, err)
+		return nil, fmt.Errorf("failed to get classes from project %s: %w", proj, err)
 	}
 	if len(classes) == 0 {
-		return proj, fmt.Errorf("No java classes found in the project %s, add java files to the appropriate directory", proj)
+		return proj, fmt.Errorf("no java classes found in the project %s, add java files to the appropriate directory", proj)
 	}
 	log.Debug("Found %d classes in the project: %v", len(classes), classes)
 
@@ -74,11 +74,11 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	}
 	criticBrain, err := mind(c.params, &criticSystemPrompt, criticStats)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create AI instance: %w", err)
+		return nil, fmt.Errorf("failed to create AI instance: %w", err)
 	}
 	criticPort, err := util.FreePort()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to find free port for critic: %w", err)
+		return nil, fmt.Errorf("failed to find free port for critic: %w", err)
 	}
 	ctc := critic.NewCritic(criticBrain, criticPort)
 	ctc.Handler(countStats(criticStats))
@@ -100,11 +100,11 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	}
 	fixerBrain, err := mind(c.params, &fixerSystemPrompt, fixerStats)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create AI instance: %w", err)
+		return nil, fmt.Errorf("failed to create AI instance: %w", err)
 	}
 	fixerPort, err := util.FreePort()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to find free port for fixer: %w", err)
+		return nil, fmt.Errorf("failed to find free port for fixer: %w", err)
 	}
 	fxr := fixer.NewFixer(fixerBrain, fixerPort)
 	fxr.Handler(countStats(fixerStats))
@@ -125,11 +125,11 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	}
 	reviewerBrain, err := mind(c.params, &reviewerSystemPrompt, reviewerStats)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create AI instance for reviewer: %w", err)
+		return nil, fmt.Errorf("failed to create AI instance for reviewer: %w", err)
 	}
 	reviewerPort, err := util.FreePort()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to find free port for reviewer: %w", err)
+		return nil, fmt.Errorf("failed to find free port for reviewer: %w", err)
 	}
 	rvwr := reviewer.NewReviewer(reviewerBrain, reviewerPort, c.params.Checks...)
 	rvwr.Handler(countStats(reviewerStats))
@@ -148,11 +148,11 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	}
 	facilitatorBrain, err := mind(c.params, &facilitatorSystemPrompt, facilitatorStats)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create AI instance: %w", err)
+		return nil, fmt.Errorf("failed to create AI instance: %w", err)
 	}
 	facilitatorPort, err := util.FreePort()
 	if err != nil {
-		return nil, fmt.Errorf("Failed to find free port for facilitator: %w", err)
+		return nil, fmt.Errorf("failed to find free port for facilitator: %w", err)
 	}
 	fclttor := facilitator.NewFacilitator(facilitatorBrain, ctc, fxr, rvwr, facilitatorPort)
 	fclttor.Handler(countStats(facilitatorStats))
@@ -205,7 +205,7 @@ func (c *RefraxClient) Refactor(proj domain.Project) (domain.Project, error) {
 	log.Info("Refactoring is finished")
 	err = printStats(c.params, criticStats, fixerStats, facilitatorStats)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to print statistics: %w", err)
+		return nil, fmt.Errorf("failed to print statistics: %w", err)
 	}
 	return proj, err
 }
@@ -220,7 +220,7 @@ func refactor(f domain.Facilitator, p domain.Project, size int, ch chan<- refact
 	log.Debug("Refactoring project %q", p)
 	all, err := p.Classes()
 	if err != nil {
-		ch <- refactoring{err: fmt.Errorf("Failed to get classes from project %s: %w", p, err)}
+		ch <- refactoring{err: fmt.Errorf("failed to get classes from project %s: %w", p, err)}
 		close(ch)
 		return
 	}
@@ -240,7 +240,7 @@ func refactor(f domain.Facilitator, p domain.Project, size int, ch chan<- refact
 	artifacts, err := f.Refactor(&job)
 	if err != nil {
 		log.Error("Failed to refactor project %s: %v", p, err)
-		ch <- refactoring{err: fmt.Errorf("Failed to refactor project %s: %w", p, err)}
+		ch <- refactoring{err: fmt.Errorf("failed to refactor project %s: %w", p, err)}
 		close(ch)
 		return
 	}
@@ -349,24 +349,24 @@ func countStats(s *stats.Stats) protocol.Handler {
 		start := time.Now()
 		resp, err := next(nil, r)
 		if err != nil {
-			return nil, fmt.Errorf("Failed to process request: %w", err)
+			return nil, fmt.Errorf("failed to process request: %w", err)
 		}
 		duration := time.Since(start)
 		jsonresp, err := json.Marshal(resp)
 		if err != nil {
-			return nil, fmt.Errorf("Failed to marshal response: %w", err)
+			return nil, fmt.Errorf("failed to marshal response: %w", err)
 		}
 		jsonreq, err := json.Marshal(r)
 		if err != nil {
-			return nil, fmt.Errorf("Failed to marshal request: %w", err)
+			return nil, fmt.Errorf("failed to marshal request: %w", err)
 		}
 		reqt, err := stats.Tokens(string(jsonreq))
 		if err != nil {
-			return nil, fmt.Errorf("Failed to count tokens for request: %w", err)
+			return nil, fmt.Errorf("failed to count tokens for request: %w", err)
 		}
 		respt, err := stats.Tokens(string(jsonresp))
 		if err != nil {
-			return nil, fmt.Errorf("Failed to count tokens for response: %w", err)
+			return nil, fmt.Errorf("failed to count tokens for response: %w", err)
 		}
 		s.A2AReq(duration, reqt, respt, len(jsonreq), len(jsonresp))
 		return resp, err

internal/critic/agent.go

@@ -43,7 +43,7 @@ func (c *agent) Review(job *domain.Job) (*domain.Artifacts, error) {
 	c.log.Debug("Rendered prompt for class %s: %s", class.Name(), prompt)
 	answer, err := c.brain.Ask(prompt.String())
 	if err != nil {
-		return nil, fmt.Errorf("Failed to get answer from brain: %w", err)
+		return nil, fmt.Errorf("failed to get answer from brain: %w", err)
 	}
 	suggestions := c.associated(parseAnswer(answer), class.Path())
 	logSuggestions(c.log, suggestions)

internal/critic/server.go

@@ -41,7 +41,7 @@ func (c *Critic) ListenAndServe() error {
 	c.log.Info("Starting critic server on port %d...", c.port)
 	var err error
 	if err = c.server.ListenAndServe(); err != nil && http.ErrServerClosed != err {
-		return fmt.Errorf("Failed to start critic server: %w", err)
+		return fmt.Errorf("failed to start critic server: %w", err)
 	}
 	return err
 }
@@ -53,7 +53,7 @@ func (c *Critic) Review(job *domain.Job) (*domain.Artifacts, error) {
 	critic := protocol.NewClient(address)
 	resp, err := critic.SendMessage(job.Marshal())
 	if err != nil {
-		return nil, fmt.Errorf("Failed to send message to critic: %w", err)
+		return nil, fmt.Errorf("failed to send message to critic: %w", err)
 	}
 	return domain.UnmarshalArtifacts(resp.Result.(*protocol.Message))
 }
@@ -62,7 +62,7 @@ func (c *Critic) Review(job *domain.Job) (*domain.Artifacts, error) {
 func (c *Critic) Shutdown() error {
 	c.log.Info("Stopping critic server...")
 	if err := c.server.Shutdown(); err != nil {
-		return fmt.Errorf("Failed to stop critic server: %w", err)
+		return fmt.Errorf("failed to stop critic server: %w", err)
 	}
 	c.log.Info("Critic server stopped successfully")
 	return nil
@@ -81,7 +81,7 @@ func (c *Critic) Ready() <-chan bool {
 func (c *Critic) think(ctx context.Context, m *protocol.Message) (*protocol.Message, error) {
 	select {
 	case <-ctx.Done():
-		return nil, fmt.Errorf("Context canceled: %w", ctx.Err())
+		return nil, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 		return c.thinkLong(m)
 	}
@@ -91,7 +91,7 @@ func (c *Critic) thinkLong(m *protocol.Message) (*protocol.Message, error) {
 	c.log.Debug("Received message: #%s", m.MessageID)
 	tsk, err := domain.UnmarshalJob(m)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to parse task from message: %w", err)
+		return nil, fmt.Errorf("failed to parse task from message: %w", err)
 	}
 	artifacts, err := c.agent.Review(tsk)
 	return artifacts.Marshal().Message, err

internal/facilitator/agent.go

@@ -24,11 +24,11 @@ type agent struct {
 func (a *agent) Refactor(job *domain.Job) (*domain.Artifacts, error) {
 	size, err := maxSize(job)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to get max size limit: %w", err)
+		return nil, fmt.Errorf("failed to get max size limit: %w", err)
 	}
 	if job.Descr.Text != "refactor the project" {
 		a.log.Warn("Received a message that is not related to refactoring, ignoring")
-		return nil, fmt.Errorf("Received a message that is not related to refactoring")
+		return nil, fmt.Errorf("received a message that is not related to refactoring")
 	}
 	classes := job.Classes
 	nclasses := len(classes)
@@ -53,7 +53,7 @@ func (a *agent) Refactor(job *domain.Job) (*domain.Artifacts, error) {
 	for range nreviewed {
 		impr := <-ch
 		if impr.err != nil {
-			return nil, fmt.Errorf("Failed to review class: %w", impr.err)
+			return nil, fmt.Errorf("failed to review class: %w", impr.err)
 		}
 		improvements = append(improvements, impr.important)
 	}
@@ -67,7 +67,7 @@ func (a *agent) Refactor(job *domain.Job) (*domain.Artifacts, error) {
 	}
 	mostImportant, err := a.mostFrequent(improvements)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to get most frequent suggestions: %w", err)
+		return nil, fmt.Errorf("failed to get most frequent suggestions: %w", err)
 	}
 	a.log.Info("Received %d most frequent suggestions from brain", len(mostImportant))
 	refactored := make([]domain.Class, 0)
@@ -104,12 +104,12 @@ func (a *agent) Refactor(job *domain.Job) (*domain.Artifacts, error) {
 		err = class.SetContent(c.Content())
 		a.log.Info("Setting content for class %s (%s)", class.Name(), class.Path())
 		if err != nil {
-			return nil, fmt.Errorf("Failed to set content for class %s: %w", class.Name(), err)
+			return nil, fmt.Errorf("failed to set content for class %s: %w", class.Name(), err)
 		}
 	}
 	err = a.stabilize(refactored)
 	if err != nil {
-		return nil, fmt.Errorf("Failed to stabilize refactored classes: %w", err)
+		return nil, fmt.Errorf("failed to stabilize refactored classes: %w", err)
 	}
 	res := &domain.Artifacts{
 		Descr:   &domain.Description{Text: "refactored classes"},
@@ -129,7 +129,7 @@ func (a *agent) stabilize(refactored []domain.Class) error {
 	counter := 3
 	for len(improvements) > 0 && counter > 0 {
 		if err != nil {
-			return fmt.Errorf("Failed to review project: %w", err)
+			return fmt.Errorf("failed to review project: %w", err)
 		}
 		perclass := a.understandClasses(refactored, improvements)
 		for k, v := range perclass {
@@ -142,14 +142,14 @@ func (a *agent) stabilize(refactored []domain.Class) error {
 			}
 			fixed, uerr := a.fixer.Fix(&job)
 			if uerr != nil {
-				return fmt.Errorf("Failed to fix project: %w", uerr)
+				return fmt.Errorf("failed to fix project: %w", uerr)
 			}
 			updated := fixed.Classes[0]
 			class := domain.NewFSClass(k.Name(), k.Path())
 			a.log.Info("Updating class %s (%s) with new content", class.Name(), class.Path())
 			uerr = class.SetContent(updated.Content())
 			if uerr != nil {
-				return fmt.Errorf("Failed to set content for class %s: %w", class.Name(), uerr)
+				return fmt.Errorf("failed to set content for class %s: %w", class.Name(), uerr)
 			}
 		}
 		counter--
@@ -188,7 +188,7 @@ func (a *agent) fix(imp improvement, example domain.Class, ch chan<- fixResult)
 	}
 	modified, err := a.fixer.Fix(&job)
 	if err != nil {
-		ch <- fixResult{fmt.Errorf("Failed to ask fixer: %w", err), nil}
+		ch <- fixResult{fmt.Errorf("failed to ask fixer: %w", err), nil}
 		return
 	}
 	ch <- fixResult{nil, modified.Classes[0]}
@@ -204,7 +204,7 @@ func (a *agent) review(class domain.Class, ch chan<- improvementResult) {
 	}
 	suggestions, err := a.critic.Review(&job)
 	if err != nil {
-		ch <- improvementResult{err: fmt.Errorf("Failed to ask critic: %w", err), important: improvement{class: class}}
+		ch <- improvementResult{err: fmt.Errorf("failed to ask critic: %w", err), important: improvement{class: class}}
 		return
 	}
 	a.log.Info("Received %d suggestions from critic", len(suggestions.Suggestions))
@@ -259,7 +259,7 @@ func (a *agent) mostFrequent(improvements []improvement) ([]improvement, error)
 	}
 	important, err := a.brain.Ask(prompt.String())
 	if err != nil {
-		return nil, fmt.Errorf("Failed to ask the brain to group suggestions: %w", err)
+		return nil, fmt.Errorf("failed to ask the brain to group suggestions: %w", err)
 	}
 
 	prompt = prompts.User{
@@ -271,7 +271,7 @@ func (a *agent) mostFrequent(improvements []improvement) ([]improvement, error)
 	a.log.Info("Choosing the most important suggestions...")
 	important, err = a.brain.Ask(prompt.String())
 	if err != nil {
-		return nil, fmt.Errorf("Failed to ask brain for most frequent suggestion: %w", err)
+		return nil, fmt.Errorf("failed to ask brain for most frequent suggestion: %w", err)
 	}
 	classSuggestions := make(map[string][]string, 0)
 	for s := range strings.SplitSeq(strings.ReplaceAll(important, "\r\n", "\n"), "\n") {
@@ -294,7 +294,7 @@ func (a *agent) mostFrequent(improvements []improvement) ([]improvement, error)
 	for k, v := range classSuggestions {
 		class, err := findClass(improvements, k)
 		if err != nil {
-			return nil, fmt.Errorf("Failed to find class %s in improvements: %w", k, err)
+			return nil, fmt.Errorf("failed to find class %s in improvements: %w", k, err)
 		}
 		var suggetions []domain.Suggestion
 		for _, s := range v {
@@ -314,7 +314,7 @@ func findClass(improvements []improvement, path string) (domain.Class, error) {
 			return imp.class, nil
 		}
 	}
-	return nil, fmt.Errorf("Class %s not found in improvements", path)
+	return nil, fmt.Errorf("class %s not found in improvements", path)
 }
 
 func maxSize(t *domain.Job) (int, error) {