feat: add caching category to Rust ecosystem

apps/cli/src/constants.ts

@@ -73,6 +73,7 @@ export const DEFAULT_CONFIG_BASE = {
   rustLibraries: [],
   rustLogging: "tracing",
   rustErrorHandling: "anyhow-thiserror",
+  rustCaching: "none",
   // Python ecosystem defaults
   pythonWebFramework: "fastapi",
   pythonOrm: "sqlalchemy",

apps/cli/src/helpers/core/command-handlers.ts

@@ -160,6 +160,7 @@ export async function createProjectHandler(
               rustLibraries: [],
               rustLogging: "none",
               rustErrorHandling: "none",
+              rustCaching: "none",
               cms: "none",
               caching: "none",
               search: "none",

apps/cli/src/helpers/core/post-installation.ts

@@ -742,6 +742,15 @@ function displayRustInstructions(config: ProjectConfig & { depsInstalled: boolea
     output += `${pc.cyan("•")} Error Handling: ${errorHandlingNames[rustErrorHandling] || rustErrorHandling}\n`;
   }
 
+  const { rustCaching } = config;
+  if (rustCaching && rustCaching !== "none") {
+    const cachingNames: Record<string, string> = {
+      moka: "Moka",
+      redis: "Redis",
+    };
+    output += `${pc.cyan("•")} Caching: ${cachingNames[rustCaching] || rustCaching}\n`;
+  }
+
   output += `\n${pc.bold("Common Cargo commands:")}\n`;
   output += `${pc.cyan("•")} Build: cargo build\n`;
   output += `${pc.cyan("•")} Run: cargo run\n`;

apps/cli/src/index.ts

@@ -96,7 +96,9 @@ import {
   RustLoggingSchema,
   type RustLogging,
   RustErrorHandlingSchema,
+  RustCachingSchema,
   type RustErrorHandling,
+  type RustCaching,
   PythonWebFrameworkSchema,
   type PythonWebFramework,
   PythonOrmSchema,
@@ -253,6 +255,7 @@ export const router = os.router({
           rustLibraries: z.array(RustLibrariesSchema).optional().describe("Rust core libraries"),
           rustLogging: RustLoggingSchema.optional().describe("Rust logging (tracing, env-logger)"),
           rustErrorHandling: RustErrorHandlingSchema.optional().describe("Rust error handling (anyhow-thiserror, eyre)"),
+          rustCaching: RustCachingSchema.optional().describe("Rust caching (moka, redis)"),
           // Python ecosystem options
           pythonWebFramework: PythonWebFrameworkSchema.optional().describe(
             "Python web framework (fastapi, django)",
@@ -582,6 +585,7 @@ export async function createVirtual(
       rustLibraries: options.rustLibraries || [],
       rustLogging: options.rustLogging || (options.ecosystem === "rust" ? "tracing" : "none"),
       rustErrorHandling: options.rustErrorHandling || (options.ecosystem === "rust" ? "anyhow-thiserror" : "none"),
+      rustCaching: options.rustCaching || "none",
       // Python ecosystem options
       pythonWebFramework: options.pythonWebFramework || "none",
       pythonOrm: options.pythonOrm || "none",

apps/cli/src/mcp.ts

@@ -52,6 +52,7 @@ import {
   RustLibrariesSchema,
   RustLoggingSchema,
   RustErrorHandlingSchema,
+  RustCachingSchema,
   RustOrmSchema,
   RustWebFrameworkSchema,
   SearchSchema,
@@ -188,6 +189,7 @@ const SCHEMA_MAP: Record<string, z.ZodType> = {
   rustLibraries: RustLibrariesSchema,
   rustLogging: RustLoggingSchema,
   rustErrorHandling: RustErrorHandlingSchema,
+  rustCaching: RustCachingSchema,
   pythonWebFramework: PythonWebFrameworkSchema,
   pythonOrm: PythonOrmSchema,
   pythonValidation: PythonValidationSchema,
@@ -210,7 +212,7 @@ const ECOSYSTEM_CATEGORIES: Record<string, string[]> = {
     "logging", "observability", "featureFlags", "analytics", "cms", "caching",
     "search", "fileStorage", "astroIntegration",
   ],
-  rust: ["rustWebFramework", "rustFrontend", "rustOrm", "rustApi", "rustCli", "rustLibraries", "rustLogging", "rustErrorHandling"],
+  rust: ["rustWebFramework", "rustFrontend", "rustOrm", "rustApi", "rustCli", "rustLibraries", "rustLogging", "rustErrorHandling", "rustCaching"],
   python: ["pythonWebFramework", "pythonOrm", "pythonValidation", "pythonAi", "pythonAuth", "pythonTaskQueue", "pythonQuality"],
   go: ["goWebFramework", "goOrm", "goApi", "goCli", "goLogging"],
   shared: ["ecosystem", "packageManager", "addons", "examples", "webDeploy", "serverDeploy", "dbSetup"],
@@ -330,6 +332,7 @@ function buildProjectConfig(
     rustLibraries: (input.rustLibraries as ProjectConfig["rustLibraries"]) ?? [],
     rustLogging: (input.rustLogging as ProjectConfig["rustLogging"]) ?? "none",
     rustErrorHandling: (input.rustErrorHandling as ProjectConfig["rustErrorHandling"]) ?? "none",
+    rustCaching: (input.rustCaching as ProjectConfig["rustCaching"]) ?? "none",
     pythonWebFramework: (input.pythonWebFramework as ProjectConfig["pythonWebFramework"]) ?? "none",
     pythonOrm: (input.pythonOrm as ProjectConfig["pythonOrm"]) ?? "none",
     pythonValidation: (input.pythonValidation as ProjectConfig["pythonValidation"]) ?? "none",
@@ -425,6 +428,7 @@ function buildCompatibilityInput(input: Record<string, unknown>): CompatibilityI
     rustLibraries: ((input.rustLibraries as string[]) ?? []).join(",") || "none",
     rustLogging: (input.rustLogging as string) ?? "none",
     rustErrorHandling: (input.rustErrorHandling as string) ?? "none",
+    rustCaching: (input.rustCaching as string) ?? "none",
     pythonWebFramework: (input.pythonWebFramework as string) ?? "none",
     pythonOrm: (input.pythonOrm as string) ?? "none",
     pythonValidation: (input.pythonValidation as string) ?? "none",
@@ -645,6 +649,7 @@ export async function startMcpServer() {
     rustLibraries: z.array(RustLibrariesSchema).optional().describe("Rust libraries"),
     rustLogging: RustLoggingSchema.optional().describe("Rust logging library"),
     rustErrorHandling: RustErrorHandlingSchema.optional().describe("Rust error handling library"),
+    rustCaching: RustCachingSchema.optional().describe("Rust caching library"),
     pythonWebFramework: PythonWebFrameworkSchema.optional().describe("Python web framework"),
     pythonOrm: PythonOrmSchema.optional().describe("Python ORM"),
     pythonValidation: PythonValidationSchema.optional().describe("Python validation"),

apps/cli/src/prompts/config-prompts.ts

@@ -44,6 +44,7 @@ import type {
   RustApi,
   RustCli,
   RustErrorHandling,
+  RustCaching,
   RustFrontend,
   RustLibraries,
   RustLogging,
@@ -118,6 +119,7 @@ import {
   getRustLibrariesChoice,
   getRustLoggingChoice,
   getRustErrorHandlingChoice,
+  getRustCachingChoice,
   getRustOrmChoice,
   getRustWebFrameworkChoice,
 } from "./rust-ecosystem";
@@ -179,6 +181,7 @@ type PromptGroupResults = {
   rustLibraries: RustLibraries[];
   rustLogging: RustLogging;
   rustErrorHandling: RustErrorHandling;
+  rustCaching: RustCaching;
   // Python ecosystem
   pythonWebFramework: PythonWebFramework;
   pythonOrm: PythonOrm;
@@ -450,6 +453,10 @@ export async function gatherConfig(
         if (results.ecosystem !== "rust") return Promise.resolve("none" as RustErrorHandling);
         return getRustErrorHandlingChoice(flags.rustErrorHandling);
       },
+      rustCaching: ({ results }) => {
+        if (results.ecosystem !== "rust") return Promise.resolve("none" as RustCaching);
+        return getRustCachingChoice(flags.rustCaching);
+      },
       // Python ecosystem prompts (skip if TypeScript or Rust)
       pythonWebFramework: ({ results }) => {
         if (results.ecosystem !== "python") return Promise.resolve("none" as PythonWebFramework);
@@ -575,6 +582,7 @@ export async function gatherConfig(
     rustLibraries: result.rustLibraries,
     rustLogging: result.rustLogging,
     rustErrorHandling: result.rustErrorHandling,
+    rustCaching: result.rustCaching,
     // Python ecosystem options
     pythonWebFramework: result.pythonWebFramework,
     pythonOrm: result.pythonOrm,

apps/cli/src/prompts/rust-ecosystem.ts

@@ -2,6 +2,7 @@ import type {
   RustApi,
   RustCli,
   RustErrorHandling,
+  RustCaching,
   RustFrontend,
   RustLibraries,
   RustLogging,
@@ -288,3 +289,35 @@ export async function getRustErrorHandlingChoice(rustErrorHandling?: RustErrorHa
 
   return response;
 }
+
+export async function getRustCachingChoice(rustCaching?: RustCaching) {
+  if (rustCaching !== undefined) return rustCaching;
+
+  const options = [
+    {
+      value: "moka" as const,
+      label: "Moka",
+      hint: "High-performance concurrent in-memory cache (Caffeine-inspired)",
+    },
+    {
+      value: "redis" as const,
+      label: "Redis",
+      hint: "Redis client with async support and connection pooling",
+    },
+    {
+      value: "none" as const,
+      label: "None",
+      hint: "No caching library",
+    },
+  ];
+
+  const response = await navigableSelect<RustCaching>({
+    message: "Select Rust caching library",
+    options,
+    initialValue: "none",
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

apps/cli/src/utils/bts-config.ts

@@ -57,6 +57,7 @@ export async function writeBtsConfig(projectConfig: ProjectConfig) {
     rustLibraries: projectConfig.rustLibraries,
     rustLogging: projectConfig.rustLogging,
     rustErrorHandling: projectConfig.rustErrorHandling,
+    rustCaching: projectConfig.rustCaching,
     pythonWebFramework: projectConfig.pythonWebFramework,
     pythonOrm: projectConfig.pythonOrm,
     pythonValidation: projectConfig.pythonValidation,
@@ -121,6 +122,7 @@ export async function writeBtsConfig(projectConfig: ProjectConfig) {
     rustLibraries: btsConfig.rustLibraries,
     rustLogging: btsConfig.rustLogging,
     rustErrorHandling: btsConfig.rustErrorHandling,
+    rustCaching: btsConfig.rustCaching,
     pythonWebFramework: btsConfig.pythonWebFramework,
     pythonOrm: btsConfig.pythonOrm,
     pythonValidation: btsConfig.pythonValidation,

apps/cli/src/utils/config-processing.ts

@@ -49,6 +49,7 @@ import type {
   RustLibraries,
   RustLogging,
   RustErrorHandling,
+  RustCaching,
   RustOrm,
   RustWebFramework,
   Runtime,
@@ -312,6 +313,10 @@ export function processFlags(options: CLIInput, projectName?: string) {
     config.rustErrorHandling = options.rustErrorHandling as RustErrorHandling;
   }
 
+  if (options.rustCaching !== undefined) {
+    config.rustCaching = options.rustCaching as RustCaching;
+  }
+
   // Python ecosystem options
   if (options.pythonWebFramework !== undefined) {
     config.pythonWebFramework = options.pythonWebFramework as PythonWebFramework;

apps/cli/src/utils/generate-reproducible-command.ts

@@ -124,6 +124,7 @@ function getRustFlags(config: ProjectConfig) {
   flags.push(formatArrayFlag("rust-libraries", config.rustLibraries));
   flags.push(`--rust-logging ${config.rustLogging}`);
   flags.push(`--rust-error-handling ${config.rustErrorHandling}`);
+  flags.push(`--rust-caching ${config.rustCaching}`);
   appendSharedNonTypeScriptFlags(flags, config);
 
   appendCommonFlags(flags, config);