internal/commands/category/category_translation/translation_push.go (1)

62-67: Filter en.json earlier to avoid adding it to localeFiles only to skip it later.

en.json is added to localeFiles at line 66, then skipped at lines 95-97. Filtering it here avoids the inconsistency.

 				if fileLocale == "categories_preferences" {
 					continue
 				}
+				// Skip English translations
+				if fileLocale == "en" {
+					continue
+				}
 				localeFiles = append(localeFiles, name)

Then remove lines 95-97.

internal/commands/category/category_translation/translation_pull.go (1)

33-36: Unreachable code: promptForOutputDirectory() always returns a non-empty value.

The helper function returns dd (defaultDir) when input is empty, so outputDir can never be empty here. This check is defensive but dead code.

Consider removing this check or adding a comment explaining it's defensive:

-			if outputDir == "" {
-				fmt.Fprintf(os.Stdout, "No output directory specified. Exiting.\n")
-				return
-			}

mgmnt/preference_translation.go (1)

31-31: Consider URL-encoding the workspace parameter.

If workspace contains special characters (spaces, slashes, etc.), the URL could be malformed. This also applies to the locale parameter in other methods.

+import "net/url"
+
 func (c *SS_MgmntClient) ListPreferenceTranslations(workspace string) (*ListPreferenceTranslation, error) {
 	client := client.NewHTTPClient()
 	defer client.Close()

-	url := fmt.Sprintf("%sv1/%s/preference_category/translation/locale", c.mgmnt_base_URL, workspace)
+	url := fmt.Sprintf("%sv1/%s/preference_category/translation/locale", c.mgmnt_base_URL, url.PathEscape(workspace))

Apply similar escaping in GetPreferenceTranslationsForLocale and PushPreferenceTranslation for both workspace and locale.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/**/!(root).go : Register each subcommand by calling `rootCmd.AddCommand(...)` in the subcommand’s own `init()` function

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to mgmnt/**/*.go : Place management and client-related Go code under the mgmnt/ directory

internal/commands/category/category_translation/helpers.go (1)

13-30: Consider expanding tilde (~) in user paths.

If a user enters a path like ~/translations, the tilde won't expand to the home directory since os.MkdirAll doesn't handle this. You could add filepath.Clean and check for a leading tilde, then expand it using os.UserHomeDir().

Example enhancement:

input = strings.TrimSpace(input)
if input == "" {
    return dd
}
// Expand tilde if present
if strings.HasPrefix(input, "~") {
    homeDir, err := os.UserHomeDir()
    if err == nil {
        input = filepath.Join(homeDir, strings.TrimPrefix(input, "~"))
    }
}
return input

internal/commands/category/category_translation/translation_list.go (2)

17-33: Handle flag errors and empty workspace more explicitly

GetString("workspace") ignores its error and allows an empty workspace to flow into ListPreferenceTranslations, which can make flag wiring issues or missing workspace hard to diagnose at runtime. Consider checking the error and validating that workspace is non-empty before calling the client, logging a clear user-facing message if either check fails.

-		workspace, _ := cmd.Flags().GetString("workspace")
+		workspace, err := cmd.Flags().GetString("workspace")
+		if err != nil {
+			log.WithError(err).Error("Failed to read --workspace flag")
+			return
+		}
+		if workspace == "" {
+			log.Error("workspace is required; please set --workspace")
+			return
+		}

---

34-43: Preserve the typed result slice when emitting empty piped output

For the len(translations.Results) == 0 && utils.IsOutputPiped() case, passing []interface{}{} to OutputData discards the concrete element type, which can lead to inconsistent schema (especially for table output, and potentially for tools introspecting struct fields). Reusing translations.Results here keeps the output shape consistent while still representing “no results”.

-		if len(translations.Results) == 0 && utils.IsOutputPiped() {
-			utils.OutputData([]interface{}{}, outputType)
-			return
-		}
-		utils.OutputData(translations.Results, outputType)
+		if len(translations.Results) == 0 && utils.IsOutputPiped() {
+			// Preserve the concrete element type for consistent schema, even when empty.
+			utils.OutputData(translations.Results, outputType)
+			return
+		}
+		utils.OutputData(translations.Results, outputType)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

internal/commands/category/category_translation/translation_push.go (1)

52-73: Consider extracting file filtering logic into a helper function.

The file filtering logic is correct but involves multiple conditions (JSON suffix check, locale filtering, exclusions). Extracting this into a helper function would improve testability and readability.

Example helper function:

// getTranslationFiles filters and returns translation files from the directory
func getTranslationFiles(files []os.DirEntry, locale string) []string {
	var localeFiles []string
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		name := file.Name()
		if strings.HasSuffix(name, ".json") {
			fileLocale := strings.TrimSuffix(name, ".json")
			if locale != "" && fileLocale != locale {
				continue
			}
			if fileLocale == "categories_preferences" {
				continue
			}
			localeFiles = append(localeFiles, name)
		}
	}
	return localeFiles
}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

internal/commands/category/category_translation/translation_push.go (2)

107-151: Avoid double-reporting the same errors (per-file log + final summary)

Each failure is both logged (log.WithError(...).Errorf(...)) and appended to errors, which are then printed at the end (Lines 145‑151). This leads to duplicated error output for the same condition.

Consider relying on the aggregated errors slice for user-facing output and downgrading/removing the per-iteration error logs, for example:

-			data, err := os.ReadFile(filePath)
-			if err != nil {
-				log.WithError(err).Errorf("Couldn't read translations from file %s", filePath)
-				failedCount++
-				errors = append(errors, fmt.Sprintf("Failed to read %s: %v", fileName, err))
-				continue
-			}
+			data, err := os.ReadFile(filePath)
+			if err != nil {
+				failedCount++
+				errors = append(errors, fmt.Sprintf("Failed to read %s: %v", fileName, err))
+				continue
+			}

Apply the same pattern to the JSON parse and push failures so each error is reported once in the final summary.

---

22-38: Validate the workspace flag before making API calls

workspace is read (Line 23) but never checked. If omitted/empty, the API call will use an empty workspace segment and fail with a generic HTTP error instead of a clear CLI message. Add an early guard that errors out with helpful usage.

Example:

-		workspace, _ := cmd.Flags().GetString("workspace")
+		workspace, _ := cmd.Flags().GetString("workspace")
+		workspace = strings.TrimSpace(workspace)
+		if workspace == "" {
+			cmd.PrintErrln("workspace flag is required")
+			_ = cmd.Usage()
+			return
+		}

This keeps failures local and consistent with other commands that require --workspace.

mgmnt/preference_translation.go (1)

27-105: Consolidate repeated HTTP error-handling logic across translation methods

ListPreferenceTranslations, GetPreferenceTranslationsForLocale, and PushPreferenceTranslation all use the same pattern:

• build URL
• execute request
• on transport error: log and return
• on res.IsError(): try to unmarshal ErrorResponse, else fall back to status

This is correct but quite duplicated. Consider extracting a small helper in mgmnt to decode management errors (e.g., taking a *resty.Response and returning an error), and possibly another helper to construct a configured HTTP client for mgmnt calls. That would reduce repetition and keep future changes to error formatting in one place.

You could also avoid the extra allocation in:

json.Unmarshal([]byte(res.String()), &errorResp)

by using the raw body instead (e.g., res.Body() or a similar accessor), depending on the resty version in use.

Overall behavior is sound; this is just for maintainability and small efficiency gains.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to mgmnt/**/*.go : Place management and client-related Go code under the mgmnt/ directory

internal/commands/category/category_translation/translation_push.go (2)

23-31: Workspace validation is good; consider signaling failure via exit code/usage.

You’ve addressed the earlier concern by validating workspace for emptiness, which is good. Right now, though, the command just logs an error and returns, which likely still exits with code 0 and shows no usage hint. For better CLI UX and scriptability, consider returning a non‑zero exit status and/or invoking cmd.Usage() or cmd.PrintErrf here so callers immediately see what went wrong.

---

111-140: Still a mix of per‑item error logging and aggregated reporting.

You’ve downgraded the file‑read failure to Debugf, which avoids duplicate user‑visible noise, but JSON parse and push failures still log at Errorf and get added to errors, which are then printed again at the end. This can result in each failure being shown twice.

To keep output concise and consistent, consider aligning all three sites:

• Either rely solely on the aggregated errors slice for user‑facing messages and keep per‑item logs at Debugf, or
• Keep Errorf logging and drop the errors slice + final printing.

For example, if you keep aggregation:

- if err := json.Unmarshal(data, &translation); err != nil {
-     log.WithError(err).Errorf("Couldn't parse translations JSON from %s", filePath)
+ if err := json.Unmarshal(data, &translation); err != nil {
+     log.WithError(err).Debugf("Couldn't parse translations JSON from %s", filePath)
      failedCount++
      errors = append(errors, fmt.Sprintf("Failed to parse JSON from %s: %v", fileName, err))
      continue
 }

- err = mgmntClient.PushPreferenceTranslation(workspace, fileLocale, translation)
- if err != nil {
-     log.WithError(err).Errorf("Couldn't push translations for locale %s", fileLocale)
+ err = mgmntClient.PushPreferenceTranslation(workspace, fileLocale, translation)
+ if err != nil {
+     log.WithError(err).Debugf("Couldn't push translations for locale %s", fileLocale)
      failedCount++
      errors = append(errors, fmt.Sprintf("Failed to push %s: %v", fileName, err))
      continue
 }

Also applies to: 150-156

internal/commands/category/category_translation/translation_push.go (1)

150-156: Consider writing aggregated errors to stderr instead of stdout.

The final error summary is printed to os.Stdout. For CLI tools, it’s often preferable to send errors to stderr so that scripts can safely pipe or capture normal output separately from failures (and detect presence of errors by checking stderr). Switching these Fprintf calls to os.Stderr would better follow that convention.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

internal/commands/category/translation/translation_push.go (1)

112-139: Inconsistent error logging levels.

The error logging uses different levels: Debugf at line 114, but Errorf at lines 123 and 132. Since all three error cases follow the same pattern (individual log + accumulated error), they should use consistent log levels.

Apply this diff to make logging consistent:

 			// Parse the JSON
 			var translation mgmnt.PreferenceTranslationContent
 			if err := json.Unmarshal(data, &translation); err != nil {
-				log.WithError(err).Errorf("Couldn't parse translations JSON from %s", filePath)
+				log.WithError(err).Debugf("Couldn't parse translations JSON from %s", filePath)
 				failedCount++
 				errors = append(errors, fmt.Sprintf("Failed to parse JSON from %s: %v", fileName, err))
 				continue
 			}
 
 			// Push translations for this locale
 			err = mgmntClient.PushPreferenceTranslation(workspace, fileLocale, translation)
 			if err != nil {
-				log.WithError(err).Errorf("Couldn't push translations for locale %s", fileLocale)
+				log.WithError(err).Debugf("Couldn't push translations for locale %s", fileLocale)
 				failedCount++
 				errors = append(errors, fmt.Sprintf("Failed to push %s: %v", fileName, err))
 				continue

This aligns with the pattern started at line 114 and avoids duplicate error output (since errors are accumulated and printed at lines 151-156).

internal/commands/category/translation/translation_list.go (1)

32-36: Ensure non-zero exit status on error.

The command logs the error and returns, which exits with status 0. For CLI automation and scripting, errors should signal failure to the shell.

Consider using os.Exit(1) after logging the error:

 		translations, err := mgmntClient.ListPreferenceTranslations(workspace)
 		if err != nil {
 			log.WithError(err).Error("Couldn't fetch translations")
+			os.Exit(1)
-			return
 		}

internal/commands/category/translation/translation_pull.go (1)

54-58: Ensure non-zero exit status on error.

The command logs the error and returns, which exits with status 0. For CLI automation and scripting, errors should signal failure to the shell.

Consider using os.Exit(1) after logging the error:

 		locales, err := mgmntClient.ListPreferenceTranslations(workspace)
 		if err != nil {
 			log.WithError(err).Errorf("Couldn't fetch translation locales from workspace '%s'", workspace)
+			os.Exit(1)
-			return
 		}

Apply the same pattern to other error cases in this function (lines 38-41).

internal/commands/category/translation/translation_push.go (1)

27-30: Good validation, but consider exit status.

The workspace validation is correctly implemented. For consistency with CLI best practices, consider exiting with a non-zero status:

 		if workspace == "" {
 			log.Error("workspace flag is required")
+			os.Exit(1)
-			return
 		}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

internal/commands/sync.go (2)

291-352: Consider organizing translation files in a subdirectory.

The function correctly implements the sync logic with appropriate error handling. However, translation files (e.g., fr.json, es.json) are written to the same directory as categories_preferences.json. While unlikely to cause conflicts, consider organizing them in a subdirectory like translations/ for better separation of concerns.

For example, update line 317:

-		filename := filepath.Join(dirPath, fmt.Sprintf("%s.json", locale))
+		translationDir := filepath.Join(dirPath, "translations")
+		os.MkdirAll(translationDir, 0755)
+		filename := filepath.Join(translationDir, fmt.Sprintf("%s.json", locale))

Otherwise, the implementation is solid with good error collection and logging.

---

304-307: Verify the hardcoded English locale skip is intentional.

The function skips "en" translations without explanation. If English is the default locale that doesn't require separate translation files, consider adding a comment to clarify this behavior.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to mgmnt/**/*.go : Place management and client-related Go code under the mgmnt/ directory

internal/commands/category/translation/translation_pull.go (1)

75-101: Consider using consistent log levels to avoid duplicate error output.

The loop logs errors at Errorf level (lines 79, 88, 95) while also accumulating them in the errors slice for the summary. When the log level includes errors, users will see duplicate messages.

For consistency with translation_push.go line 119 (which uses Debugf), consider using Debugf for per-iteration logging and reserving the aggregated summary for user-facing output.

 		translations, err := mgmntClient.GetPreferenceTranslationsForLocale(workspace, locale)
 		if err != nil {
-			log.WithError(err).Errorf("Couldn't fetch translations for locale '%s' from workspace '%s'", locale, workspace)
+			log.WithError(err).Debugf("Couldn't fetch translations for locale '%s' from workspace '%s'", locale, workspace)
 			failedCount++
 			errors = append(errors, fmt.Sprintf("Locale '%s': Failed to fetch translations from workspace '%s' - %v", locale, workspace, err))
 			continue

internal/commands/category/translation/translation_push.go (1)

125-141: Inconsistent log levels within the error handling loop.

Line 119 uses Debugf (as addressed from prior review), but lines 128 and 137 still use Errorf. This results in inconsistent behavior where some errors are logged twice (via log and the accumulated summary) while others are not.

For consistency, consider using Debugf for all per-iteration errors:

 		var translation mgmnt.PreferenceTranslationContent
 		if err := json.Unmarshal(data, &translation); err != nil {
-			log.WithError(err).Errorf("Couldn't parse translations JSON from %s", filePath)
+			log.WithError(err).Debugf("Couldn't parse translations JSON from %s", filePath)
 			failedCount++
 			errors = append(errors, fmt.Sprintf("Failed to parse JSON from %s: %v", fileName, err))
 			continue
 		}

 		// Push translations for this locale
 		err = mgmntClient.PushPreferenceTranslation(workspace, fileLocale, translation)
 		if err != nil {
-			log.WithError(err).Errorf("Couldn't push translations for locale %s", fileLocale)
+			log.WithError(err).Debugf("Couldn't push translations for locale %s", fileLocale)
 			failedCount++
 			errors = append(errors, fmt.Sprintf("Failed to push %s: %v", fileName, err))
 			continue
 		}

internal/commands/category/category_commit.go (1)

52-54: Consider clarifying the --dir flag semantics and handling missing translations gracefully.

Two observations:

1. Flag description mismatch: The --dir flag is described as "Output directory for categories" (line 59), but here it's used as an input directory to read translations from. Consider updating the description to reflect its dual purpose, e.g., "Directory for categories (used for reading translations during commit)".

2. Silent failure on missing translations: If the translation directory doesn't exist (e.g., user commits without prior pull), PushTranslations logs an error and returns, but the category commit still succeeds. This may surprise users who expect translations to be pushed.

Consider adding a check or user feedback:

 		// Push translations after committing categories
+		if _, err := os.Stat(translationDir); os.IsNotExist(err) {
+			log.Warnf("Translation directory %s does not exist, skipping translation push", translationDir)
+		} else {
 			translation.PushTranslations(workspace, "", translationDir)
+		}

And update the flag description:

-	categoryCommitCmd.Flags().StringP("dir", "d", "", "Output directory for categories (default: ./suprsend/category)")
+	categoryCommitCmd.Flags().StringP("dir", "d", "", "Category directory (default: ./suprsend/category)")

Also applies to: 59-59

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/root.go : Define the root command and global flags in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to cmd/suprsend/main.go : The CLI entry point is cmd/suprsend/main.go and should invoke commands.Execute()

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/utils/banner.go : Print the CLI banner from internal/utils/banner.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to cmd/suprsend/main.go : Ensure the main entry point calls `commands.Execute()` to run the CLI

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/root.go : Define the CLI root command as `rootCmd` in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/**/!(root).go : Register each subcommand by calling `rootCmd.AddCommand(...)` in the subcommand’s own `init()` function

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/root.go : Define the root command and global flags in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to cmd/suprsend/main.go : The CLI entry point is cmd/suprsend/main.go and should invoke commands.Execute()

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

internal/commands/category/category_push.go (1)

27-31: Translation directory setup is correct.

The logic appropriately defaults to ./suprsend/category/translation when no directory is specified and correctly uses the provided path when available.

Note: Similar translationDir computation logic exists in category_commit.go (lines 24-31). Consider extracting to a helper function if this pattern repeats in additional files.

internal/commands/category/category_commit.go (1)

22-31: Translation directory computation is correct.

The logic correctly defaults to ./suprsend/category/translation and properly handles the custom directory flag.

Note: This logic duplicates the translationDir computation in category_push.go (lines 27-31). Consider extracting to a shared helper if this pattern expands to additional commands.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to cmd/suprsend/main.go : The CLI entry point is cmd/suprsend/main.go and should invoke commands.Execute()

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/utils/banner.go : Print the CLI banner from internal/utils/banner.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/root.go : Define the root command and global flags in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to cmd/suprsend/main.go : Ensure the main entry point calls `commands.Execute()` to run the CLI

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/root.go : Define the CLI root command as `rootCmd` in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/**/!(root).go : Register each subcommand by calling `rootCmd.AddCommand(...)` in the subcommand’s own `init()` function

internal/commands/category/category_push.go (1)

50-62: Spinner and translation push sequencing could be cleaned up

translation.PushTranslations likely shows its own progress/output, while this command’s spinner ("Pushing categories...") is already running when translations are pushed. That can (a) produce overlapping spinner output and (b) slightly mislabel the phase, since translations are being pushed before categories. Consider either starting p only after PushTranslations returns, or updating the message / reusing a single progress indicator for both steps.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to cmd/suprsend/main.go : The CLI entry point is cmd/suprsend/main.go and should invoke commands.Execute()

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/utils/banner.go : Print the CLI banner from internal/utils/banner.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/root.go : Define the root command and global flags in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to cmd/suprsend/main.go : Ensure the main entry point calls `commands.Execute()` to run the CLI

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/root.go : Define the CLI root command as `rootCmd` in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/**/!(root).go : Register each subcommand by calling `rootCmd.AddCommand(...)` in the subcommand’s own `init()` function

internal/commands/category/category_pull.go (1)

68-70: Good sequencing of translation pull after categories write

Calling translation.PullTranslations only after a successful category fetch/write, and scoping it under outputDir/translation, is a sensible integration and keeps translation artifacts organized alongside categories. Behavior and error handling remain clear and localized to the translation helper.

If you ever want stricter failure semantics, consider having PullTranslations return an error so this command can decide whether a translation failure should affect the overall exit status; not necessary for this PR but could tighten observability later.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to cmd/suprsend/main.go : The CLI entry point is cmd/suprsend/main.go and should invoke commands.Execute()

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/utils/banner.go : Print the CLI banner from internal/utils/banner.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/*.go : Register subcommands via init() functions in files under internal/commands/

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/cli-structure.mdc:0-0
Timestamp: 2025-08-25T08:53:18.379Z
Learning: Applies to internal/commands/root.go : Define the root command and global flags in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to cmd/suprsend/main.go : Ensure the main entry point calls `commands.Execute()` to run the CLI

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/root.go : Define the CLI root command as `rootCmd` in internal/commands/root.go

Learnt from: CR
Repo: suprsend/cli PR: 0
File: .cursor/rules/command-registration.mdc:0-0
Timestamp: 2025-08-25T08:53:44.887Z
Learning: Applies to internal/commands/**/!(root).go : Register each subcommand by calling `rootCmd.AddCommand(...)` in the subcommand’s own `init()` function