@mandujs/cli 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Agent-Native Fullstack Framework - 에이전트가 코딩해도 아키텍처가 무너지지 않는 개발 OS",
   "type": "module",
   "main": "./src/main.ts",
@@ -32,8 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mandujs/core": "^0.16.0",
-    "@mandujs/ate": "0.16.0",
+    "@mandujs/core": "0.18.0",
+    "@mandujs/ate": "0.17.0",
     "cfonts": "^3.3.0"
   },
   "engines": {

package/src/commands/__tests__/generate-resource.test.ts

@@ -0,0 +1,231 @@
+/**
+ * CLI Integration Tests - generate-resource command
+ *
+ * QA Engineer: Integration testing for CLI resource generation
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { parseFieldsFlag, parseMethodsFlag, formatSchemaFile } from "../generate-resource";
+import type { ResourceDefinition } from "@mandujs/core";
+
+describe("CLI - Field Parsing", () => {
+  test("should parse simple fields string", () => {
+    const result = parseFieldsFlag("name:string,email:email,age:number");
+
+    expect(result.name).toBeDefined();
+    expect(result.name.type).toBe("string");
+    expect(result.email.type).toBe("email");
+    expect(result.age.type).toBe("number");
+  });
+
+  test("should handle optional fields with ?", () => {
+    const result = parseFieldsFlag("name:string,bio:string?");
+
+    expect(result.name.required).toBe(true);
+    expect(result.bio.required).toBe(false);
+  });
+
+  test("should handle required fields with !", () => {
+    const result = parseFieldsFlag("email:email!");
+
+    expect(result.email.required).toBe(true);
+  });
+
+  test("should handle all field types", () => {
+    const fields = parseFieldsFlag(
+      "str:string,num:number,bool:boolean,dt:date,id:uuid,mail:email,link:url,data:json"
+    );
+
+    expect(fields.str.type).toBe("string");
+    expect(fields.num.type).toBe("number");
+    expect(fields.bool.type).toBe("boolean");
+    expect(fields.dt.type).toBe("date");
+    expect(fields.id.type).toBe("uuid");
+    expect(fields.mail.type).toBe("email");
+    expect(fields.link.type).toBe("url");
+    expect(fields.data.type).toBe("json");
+  });
+
+  test("should throw on invalid field format", () => {
+    expect(() => parseFieldsFlag("invalid")).toThrow(/Invalid field format/);
+    expect(() => parseFieldsFlag("name:")).toThrow(/Invalid field format/);
+    expect(() => parseFieldsFlag(":string")).toThrow(/Invalid field format/);
+  });
+
+  test("should throw on invalid field type", () => {
+    expect(() => parseFieldsFlag("field:invalidtype")).toThrow(/Invalid field type/);
+  });
+
+  test("should handle whitespace gracefully", () => {
+    const result = parseFieldsFlag("  name:string  ,  email:email  ");
+
+    expect(result.name).toBeDefined();
+    expect(result.email).toBeDefined();
+  });
+});
+
+describe("CLI - Methods Parsing", () => {
+  test("should parse GET,POST,PUT,DELETE", () => {
+    const endpoints = parseMethodsFlag("GET,POST,PUT,DELETE");
+
+    expect(endpoints.list).toBe(true);
+    expect(endpoints.get).toBe(true);
+    expect(endpoints.create).toBe(true);
+    expect(endpoints.update).toBe(true);
+    expect(endpoints.delete).toBe(true);
+  });
+
+  test("should parse partial methods", () => {
+    const endpoints = parseMethodsFlag("GET,POST");
+
+    expect(endpoints.list).toBe(true);
+    expect(endpoints.get).toBe(true);
+    expect(endpoints.create).toBe(true);
+    expect(endpoints.update).toBe(false);
+    expect(endpoints.delete).toBe(false);
+  });
+
+  test("should handle lowercase methods", () => {
+    const endpoints = parseMethodsFlag("get,post");
+
+    expect(endpoints.list).toBe(true);
+    expect(endpoints.create).toBe(true);
+  });
+
+  test("should handle single method", () => {
+    const endpoints = parseMethodsFlag("GET");
+
+    expect(endpoints.list).toBe(true);
+    expect(endpoints.get).toBe(true);
+    expect(endpoints.create).toBe(false);
+  });
+
+  test("should handle whitespace", () => {
+    const endpoints = parseMethodsFlag("  GET  ,  POST  ");
+
+    expect(endpoints.list).toBe(true);
+    expect(endpoints.create).toBe(true);
+  });
+});
+
+describe("CLI - Schema File Formatting", () => {
+  test("should generate valid TypeScript schema file", () => {
+    const definition: ResourceDefinition = {
+      name: "user",
+      fields: {
+        id: { type: "uuid", required: true },
+        name: { type: "string", required: true },
+        email: { type: "email", required: true },
+        age: { type: "number", required: false },
+      },
+      options: {
+        description: "User management API",
+        tags: ["user"],
+        endpoints: {
+          list: true,
+          get: true,
+          create: true,
+          update: true,
+          delete: true,
+        },
+      },
+    };
+
+    const schemaFile = formatSchemaFile(definition);
+
+    // Verify structure
+    expect(schemaFile).toContain('import { defineResource } from "@mandujs/core"');
+    expect(schemaFile).toContain("export const UserResource = defineResource({");
+    expect(schemaFile).toContain('name: "user"');
+
+    // Verify fields
+    expect(schemaFile).toContain('id: { type: "uuid", required: true }');
+    expect(schemaFile).toContain('name: { type: "string", required: true }');
+    expect(schemaFile).toContain('email: { type: "email", required: true }');
+    expect(schemaFile).toContain('age: { type: "number", required: false }');
+
+    // Verify options
+    expect(schemaFile).toContain('description: "User management API"');
+    expect(schemaFile).toContain('tags: ["user"]');
+    expect(schemaFile).toContain("list: true");
+    expect(schemaFile).toContain("get: true");
+    expect(schemaFile).toContain("create: true");
+  });
+
+  test("should handle minimal definition", () => {
+    const definition: ResourceDefinition = {
+      name: "item",
+      fields: {
+        id: { type: "uuid", required: true },
+      },
+    };
+
+    const schemaFile = formatSchemaFile(definition);
+
+    expect(schemaFile).toContain('name: "item"');
+    expect(schemaFile).toContain('id: { type: "uuid", required: true }');
+  });
+
+  test("should capitalize resource name in export", () => {
+    const definition: ResourceDefinition = {
+      name: "product",
+      fields: {
+        id: { type: "uuid", required: true },
+      },
+    };
+
+    const schemaFile = formatSchemaFile(definition);
+
+    expect(schemaFile).toContain("export const ProductResource = defineResource({");
+  });
+});
+
+describe("CLI - Error Messages", () => {
+  test("should provide helpful error for invalid field format", () => {
+    try {
+      parseFieldsFlag("name-string");
+      expect(false).toBe(true); // Should not reach here
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toContain("Invalid field format");
+      expect((error as Error).message).toContain("name-string");
+      expect((error as Error).message).toContain("Expected format: fieldName:fieldType");
+    }
+  });
+
+  test("should provide helpful error for invalid type", () => {
+    try {
+      parseFieldsFlag("name:text");
+      expect(false).toBe(true); // Should not reach here
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toContain("Invalid field type");
+      expect((error as Error).message).toContain("text");
+      expect((error as Error).message).toContain("Valid types:");
+    }
+  });
+});
+
+describe("CLI - Edge Cases", () => {
+  test("should handle empty string gracefully", () => {
+    const result = parseFieldsFlag("");
+    expect(Object.keys(result).length).toBe(0);
+  });
+
+  test("should skip empty segments", () => {
+    const result = parseFieldsFlag("name:string,,email:email");
+    expect(Object.keys(result).length).toBe(2);
+  });
+
+  test("should handle very long field names", () => {
+    const longName = "a".repeat(50);
+    const result = parseFieldsFlag(`${longName}:string`);
+    expect(result[longName]).toBeDefined();
+  });
+
+  test("should handle camelCase and snake_case", () => {
+    const result = parseFieldsFlag("firstName:string,last_name:string");
+    expect(result.firstName).toBeDefined();
+    expect(result.last_name).toBeDefined();
+  });
+});

package/src/commands/generate-apply.ts

@@ -1,12 +1,62 @@
-import { loadManifest, generateManifest, generateRoutes, buildGenerateReport, printReportSummary, writeReport } from "@mandujs/core";
+import {
+  loadManifest,
+  generateManifest,
+  generateRoutes,
+  buildGenerateReport,
+  printReportSummary,
+  writeReport,
+  parseResourceSchemas,
+  generateResourcesArtifacts,
+  logGeneratorResult,
+} from "@mandujs/core";
 import { resolveFromCwd, getRootDir } from "../util/fs";
+import path from "path";
+import fs from "fs/promises";
 
-export async function generateApply(): Promise<boolean> {
+/**
+ * Discover resource schema files in spec/resources/
+ */
+async function discoverResourceSchemas(rootDir: string): Promise<string[]> {
+  const resourcesDir = path.join(rootDir, "spec/resources");
+
+  try {
+    await fs.access(resourcesDir);
+  } catch {
+    // spec/resources doesn't exist, no resources to discover
+    return [];
+  }
+
+  const schemaPaths: string[] = [];
+
+  async function scanDir(dir: string): Promise<void> {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively scan subdirectories
+        await scanDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".resource.ts")) {
+        schemaPaths.push(fullPath);
+      }
+    }
+  }
+
+  await scanDir(resourcesDir);
+  return schemaPaths;
+}
+
+export async function generateApply(options?: { force?: boolean }): Promise<boolean> {
   const rootDir = getRootDir();
   const manifestPath = resolveFromCwd(".mandu/routes.manifest.json");
 
   console.log(`🥟 Mandu Generate`);
-  console.log(`📄 FS Routes 기반 코드 생성\n`);
+  console.log(`📄 FS Routes + Resources 코드 생성\n`);
+
+  // ============================================
+  // 1. Generate FS Routes artifacts
+  // ============================================
 
   // Regenerate manifest from FS Routes
   const fsResult = await generateManifest(rootDir);
@@ -20,7 +70,7 @@ export async function generateApply(): Promise<boolean> {
     return false;
   }
 
-  console.log(`🔄 코드 생성 중...\n`);
+  console.log(`🔄 FS Routes 코드 생성 중...\n`);
 
   const generateResult = await generateRoutes(result.data, rootDir);
 
@@ -32,10 +82,60 @@ export async function generateApply(): Promise<boolean> {
   console.log(`📋 Report 저장: ${reportPath}`);
 
   if (!generateResult.success) {
-    console.log(`\n❌ generate 실패`);
+    console.log(`\n❌ FS Routes generate 실패`);
     return false;
   }
 
+  console.log(`\n✅ FS Routes generate 완료`);
+
+  // ============================================
+  // 2. Generate Resource artifacts
+  // ============================================
+
+  console.log(`\n🔍 리소스 스키마 검색 중...\n`);
+
+  const schemaPaths = await discoverResourceSchemas(rootDir);
+
+  if (schemaPaths.length === 0) {
+    console.log(`📋 리소스 스키마 없음 (spec/resources/*.resource.ts)`);
+    console.log(`💡 리소스 생성: bunx mandu generate resource`);
+  } else {
+    console.log(`📋 ${schemaPaths.length}개 리소스 스키마 발견`);
+    schemaPaths.forEach((p) =>
+      console.log(`   - ${path.relative(rootDir, p)}`)
+    );
+
+    try {
+      console.log(`\n🔄 리소스 아티팩트 생성 중...\n`);
+
+      const resources = await parseResourceSchemas(schemaPaths);
+      const resourceResult = await generateResourcesArtifacts(resources, {
+        rootDir,
+        force: options?.force ?? false,
+      });
+
+      logGeneratorResult(resourceResult);
+
+      if (!resourceResult.success) {
+        console.log(`\n❌ 리소스 generate 실패`);
+        return false;
+      }
+
+      console.log(`\n✅ 리소스 generate 완료`);
+    } catch (error) {
+      console.error(
+        `\n❌ 리소스 generate 오류: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+      return false;
+    }
+  }
+
+  // ============================================
+  // Final Summary
+  // ============================================
+
   console.log(`\n✅ generate 완료`);
   console.log(`💡 다음 단계: bunx mandu guard`);
 

package/src/commands/generate-resource.ts

@@ -0,0 +1,396 @@
+/**
+ * Mandu CLI - Generate Resource Command
+ * Interactive and flag-based resource creation
+ */
+
+import {
+  defineResource,
+  type ResourceDefinition,
+  type ResourceField,
+  type FieldType,
+  FieldTypes,
+  generateResourceArtifacts,
+  parseResourceSchema,
+  logGeneratorResult,
+} from "@mandujs/core";
+import path from "path";
+import fs from "fs/promises";
+import { createInterface } from "readline/promises";
+
+// ============================================
+// Types
+// ============================================
+
+export interface GenerateResourceOptions {
+  name?: string;
+  fields?: string;
+  timestamps?: boolean;
+  methods?: string;
+  force?: boolean;
+}
+
+interface InteractiveAnswers {
+  name: string;
+  fields: Record<string, ResourceField>;
+  timestamps: boolean;
+  endpoints: string[];
+}
+
+// ============================================
+// Field Parsing
+// ============================================
+
+/**
+ * Parse fields flag string to ResourceField objects
+ *
+ * @example
+ * "name:string,email:email,age:number" → { name: { type: "string" }, ... }
+ */
+export function parseFieldsFlag(input: string): Record<string, ResourceField> {
+  const fields: Record<string, ResourceField> = {};
+
+  for (const fieldStr of input.split(",")) {
+    const trimmed = fieldStr.trim();
+    if (!trimmed) continue;
+
+    // Parse: "name:string?" or "email:email!"
+    const match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*):([a-z]+)([?!])?$/);
+
+    if (!match) {
+      throw new Error(
+        `Invalid field format: "${fieldStr}". Expected format: fieldName:fieldType (e.g., name:string)`
+      );
+    }
+
+    const [, name, type, modifier] = match;
+
+    // Validate type
+    if (!FieldTypes.includes(type as FieldType)) {
+      throw new Error(
+        `Invalid field type: "${type}". Valid types: ${FieldTypes.join(", ")}`
+      );
+    }
+
+    fields[name] = {
+      type: type as FieldType,
+      required: modifier !== "?",
+      description: undefined,
+    };
+  }
+
+  return fields;
+}
+
+/**
+ * Parse methods flag to endpoints configuration
+ *
+ * @example
+ * "GET,POST,PUT,DELETE" → { list: true, get: true, create: true, update: true, delete: true }
+ */
+export function parseMethodsFlag(input: string): Record<string, boolean> {
+  const methods = input.split(",").map((m) => m.trim().toUpperCase());
+  const endpoints: Record<string, boolean> = {
+    list: false,
+    get: false,
+    create: false,
+    update: false,
+    delete: false,
+  };
+
+  for (const method of methods) {
+    switch (method) {
+      case "GET":
+        endpoints.list = true;
+        endpoints.get = true;
+        break;
+      case "POST":
+        endpoints.create = true;
+        break;
+      case "PUT":
+      case "PATCH":
+        endpoints.update = true;
+        break;
+      case "DELETE":
+        endpoints.delete = true;
+        break;
+      default:
+        throw new Error(
+          `Invalid HTTP method: "${method}". Valid: GET, POST, PUT, PATCH, DELETE`
+        );
+    }
+  }
+
+  return endpoints;
+}
+
+// ============================================
+// Interactive Mode
+// ============================================
+
+/**
+ * Run interactive prompts to gather resource information
+ */
+async function runInteractiveMode(): Promise<InteractiveAnswers> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log("\n🥟 Create a new resource\n");
+
+  // Resource name
+  const name = await rl.question("Resource name (singular, e.g., 'user'): ");
+  if (!name || !/^[a-z][a-z0-9_]*$/i.test(name)) {
+    rl.close();
+    throw new Error(
+      "Invalid resource name. Must start with a letter and contain only letters, numbers, and underscores."
+    );
+  }
+
+  // Fields
+  console.log("\nAdd fields (press Enter with empty input to finish):");
+  const fields: Record<string, ResourceField> = {};
+  let fieldIndex = 0;
+
+  while (true) {
+    fieldIndex++;
+    const fieldInput = await rl.question(
+      `  Field ${fieldIndex} (format: name:type, or empty to finish): `
+    );
+
+    if (!fieldInput.trim()) {
+      if (fieldIndex === 1) {
+        rl.close();
+        throw new Error("Resource must have at least one field");
+      }
+      break;
+    }
+
+    try {
+      const parsed = parseFieldsFlag(fieldInput);
+      Object.assign(fields, parsed);
+    } catch (error) {
+      console.error(
+        `  ❌ ${error instanceof Error ? error.message : String(error)}`
+      );
+      fieldIndex--; // Retry this field
+    }
+  }
+
+  // Timestamps
+  const timestampsAnswer = await rl.question(
+    "\nAdd timestamp fields (createdAt, updatedAt)? (y/N): "
+  );
+  const timestamps = timestampsAnswer.toLowerCase() === "y";
+
+  // Endpoints
+  console.log("\nSelect endpoints to generate:");
+  const listAnswer = await rl.question("  - List all (GET /resources)? (Y/n): ");
+  const getAnswer = await rl.question("  - Get one (GET /resources/:id)? (Y/n): ");
+  const createAnswer = await rl.question("  - Create (POST /resources)? (Y/n): ");
+  const updateAnswer = await rl.question(
+    "  - Update (PUT /resources/:id)? (Y/n): "
+  );
+  const deleteAnswer = await rl.question(
+    "  - Delete (DELETE /resources/:id)? (Y/n): "
+  );
+
+  const endpoints: string[] = [];
+  if (listAnswer.toLowerCase() !== "n") endpoints.push("list");
+  if (getAnswer.toLowerCase() !== "n") endpoints.push("get");
+  if (createAnswer.toLowerCase() !== "n") endpoints.push("create");
+  if (updateAnswer.toLowerCase() !== "n") endpoints.push("update");
+  if (deleteAnswer.toLowerCase() !== "n") endpoints.push("delete");
+
+  rl.close();
+
+  return { name, fields, timestamps, endpoints };
+}
+
+// ============================================
+// Schema File Generation
+// ============================================
+
+/**
+ * Format resource definition as TypeScript code
+ */
+export function formatSchemaFile(definition: ResourceDefinition): string {
+  const { name, fields, options } = definition;
+
+  const fieldsCode = Object.entries(fields)
+    .map(([fieldName, field]) => {
+      const parts: string[] = [`type: "${field.type}"`];
+      if (field.required !== undefined) parts.push(`required: ${field.required}`);
+      if (field.description) parts.push(`description: "${field.description}"`);
+      return `    ${fieldName}: { ${parts.join(", ")} },`;
+    })
+    .join("\n");
+
+  const endpointsCode = options?.endpoints
+    ? Object.entries(options.endpoints)
+        .map(([endpoint, enabled]) => `      ${endpoint}: ${enabled},`)
+        .join("\n")
+    : "";
+
+  return `import { defineResource } from "@mandujs/core";
+
+/**
+ * ${name.charAt(0).toUpperCase() + name.slice(1)} Resource
+ * Auto-generated by Mandu CLI
+ */
+export const ${name.charAt(0).toUpperCase() + name.slice(1)}Resource = defineResource({
+  name: "${name}",
+  fields: {
+${fieldsCode}
+  },
+  options: {
+    description: "${name.charAt(0).toUpperCase() + name.slice(1)} management API",
+    tags: ["${name}"],
+    endpoints: {
+${endpointsCode}
+    },
+  },
+});
+`;
+}
+
+/**
+ * Create schema file in spec/resources/{name}/schema.ts
+ */
+async function createSchemaFile(
+  rootDir: string,
+  definition: ResourceDefinition
+): Promise<string> {
+  const resourceDir = path.join(rootDir, "spec/resources", definition.name);
+  const schemaPath = path.join(resourceDir, "schema.ts");
+
+  // Check if already exists
+  try {
+    await fs.access(schemaPath);
+    throw new Error(
+      `Resource schema already exists: ${path.relative(rootDir, schemaPath)}\nUse --force to overwrite.`
+    );
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.includes("Resource schema already exists")
+    ) {
+      throw error;
+    }
+    // File doesn't exist, we can create it
+  }
+
+  // Create directory
+  await fs.mkdir(resourceDir, { recursive: true });
+
+  // Write schema file
+  const content = formatSchemaFile(definition);
+  await Bun.write(schemaPath, content);
+
+  return schemaPath;
+}
+
+// ============================================
+// Main Command
+// ============================================
+
+/**
+ * Generate resource command
+ */
+export async function generateResource(
+  options: GenerateResourceOptions
+): Promise<boolean> {
+  const rootDir = process.cwd();
+
+  try {
+    let definition: ResourceDefinition;
+
+    // Interactive mode or flag-based mode
+    if (!options.name || !options.fields) {
+      // Interactive mode
+      const answers = await runInteractiveMode();
+
+      // Add timestamps if requested
+      if (answers.timestamps) {
+        answers.fields.createdAt = { type: "date", required: true };
+        answers.fields.updatedAt = { type: "date", required: true };
+      }
+
+      // Build endpoints config
+      const endpoints: Record<string, boolean> = {
+        list: answers.endpoints.includes("list"),
+        get: answers.endpoints.includes("get"),
+        create: answers.endpoints.includes("create"),
+        update: answers.endpoints.includes("update"),
+        delete: answers.endpoints.includes("delete"),
+      };
+
+      definition = defineResource({
+        name: answers.name,
+        fields: answers.fields,
+        options: { endpoints },
+      });
+    } else {
+      // Flag-based mode
+      const fields = parseFieldsFlag(options.fields);
+
+      // Add timestamps if requested
+      if (options.timestamps) {
+        fields.createdAt = { type: "date", required: true };
+        fields.updatedAt = { type: "date", required: true };
+      }
+
+      // Parse methods if provided
+      const endpoints = options.methods
+        ? parseMethodsFlag(options.methods)
+        : {
+            list: true,
+            get: true,
+            create: true,
+            update: true,
+            delete: true,
+          };
+
+      definition = defineResource({
+        name: options.name,
+        fields,
+        options: { endpoints },
+      });
+    }
+
+    console.log(`\n🥟 Generating resource: ${definition.name}\n`);
+
+    // 1. Create schema file
+    const schemaPath = await createSchemaFile(rootDir, definition);
+    console.log(`✅ Created schema: ${path.relative(rootDir, schemaPath)}`);
+
+    // 2. Generate artifacts
+    const parsed = await parseResourceSchema(schemaPath);
+    const result = await generateResourceArtifacts(parsed, {
+      rootDir,
+      force: options.force ?? false,
+    });
+
+    // 3. Log results
+    logGeneratorResult(result);
+
+    if (!result.success) {
+      console.log("\n❌ Resource generation failed");
+      return false;
+    }
+
+    // 4. Success guidance
+    console.log("\n✅ Resource generated successfully!");
+    console.log("\n💡 Next steps:");
+    console.log(`   1. Edit slot implementation: spec/slots/${definition.name}.slot.ts`);
+    console.log(`   2. Run \`mandu dev\` to start development server`);
+    console.log(`   3. Test API endpoints with your resource\n`);
+
+    return true;
+  } catch (error) {
+    console.error(
+      `\n❌ Error: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return false;
+  }
+}

package/src/commands/registry.ts

@@ -400,9 +400,31 @@ registerCommand({
 
 registerCommand({
   id: "generate",
-  description: "FS Routes 기반 코드 생성",
-  async run() {
+  description: "코드 생성 (FS Routes + Resources)",
+  subcommands: ["resource"],
+  async run(ctx) {
+    const subCommand = ctx.args[1];
+
+    if (subCommand === "resource") {
+      // generate resource subcommand
+      const { generateResource } = await import("./generate-resource");
+      return generateResource({
+        name: ctx.args[2] || ctx.options._positional,
+        fields: ctx.options.fields,
+        timestamps: ctx.options.timestamps === "true",
+        methods: ctx.options.methods,
+        force: ctx.options.force === "true",
+      });
+    }
+
+    // Default: generate all (FS Routes + Resources)
+    if (subCommand && !subCommand.startsWith("--")) {
+      return false; // Unknown subcommand
+    }
+
     const { generateApply } = await import("./generate-apply");
-    return generateApply();
+    return generateApply({
+      force: ctx.options.force === "true",
+    });
   },
 });

package/src/main.ts

@@ -20,19 +20,20 @@ ${theme.heading("🥟 Mandu CLI")} ${theme.muted(`v${VERSION}`)} - Agent-Native
 ${theme.heading("Usage:")} ${theme.command("bunx mandu")} ${theme.option("<command>")} [options]
 
 Commands:
-  init              새 프로젝트 생성 (Tailwind + shadcn/ui 기본 포함)
-  check             FS Routes + Guard 통합 검사
-  routes generate   FS Routes 스캔 및 매니페스트 생성
-  routes list       현재 라우트 목록 출력
-  routes watch      실시간 라우트 감시
-  dev               개발 서버 실행 (FS Routes + Guard 기본)
-  build             클라이언트 번들 빌드 (Hydration)
-  start             프로덕션 서버 실행 (build 후)
-  guard             아키텍처 위반 검사 (기본)
-  guard arch        아키텍처 위반 검사 (FSD/Clean/Hexagonal)
-  guard legacy      레거시 Spec Guard 검사
-  spec-upsert       Spec 파일 검증 및 lock 갱신 (레거시)
-  generate          Spec에서 코드 생성 (레거시)
+  init                    새 프로젝트 생성 (Tailwind + shadcn/ui 기본 포함)
+  check                   FS Routes + Guard 통합 검사
+  routes generate         FS Routes 스캔 및 매니페스트 생성
+  routes list             현재 라우트 목록 출력
+  routes watch            실시간 라우트 감시
+  dev                     개발 서버 실행 (FS Routes + Guard 기본)
+  build                   클라이언트 번들 빌드 (Hydration)
+  start                   프로덕션 서버 실행 (build 후)
+  guard                   아키텍처 위반 검사 (기본)
+  guard arch              아키텍처 위반 검사 (FSD/Clean/Hexagonal)
+  guard legacy            레거시 Spec Guard 검사
+  generate                FS Routes + Resources 코드 생성
+  generate resource       리소스 생성 (Interactive 또는 Flag 기반)
+  spec-upsert             Spec 파일 검증 및 lock 갱신 (레거시)
 
   doctor            Guard 실패 분석 + 패치 제안 (Brain)
   watch             실시간 파일 감시 - 경고만 (Brain)
@@ -101,6 +102,10 @@ Options:
   --model <name>      brain setup 시 모델 이름 (기본: llama3.2)
   --url <url>         brain setup 시 Ollama URL
   --skip-check        brain setup 시 모델/서버 체크 건너뜀
+  --fields <fields>   generate resource 시 필드 정의 (예: name:string,email:email)
+  --timestamps        generate resource 시 createdAt/updatedAt 자동 추가
+  --methods <methods> generate resource 시 HTTP 메서드 (예: GET,POST,PUT,DELETE)
+  --force             generate/generate resource 시 기존 슬롯 덮어쓰기
   --help, -h          도움말 표시
 
 Notes:
@@ -135,10 +140,18 @@ Examples:
   bunx mandu lock                          # Lockfile 생성/갱신
   bunx mandu lock --verify                 # 설정 무결성 검증
   bunx mandu lock --diff --show-secrets    # 변경사항 상세 비교
+  bunx mandu generate resource             # Interactive 리소스 생성
+  bunx mandu generate resource user --fields name:string,email:email --timestamps
+  bunx mandu generate resource product --fields name:string,price:number --methods GET,POST,PUT
+  bunx mandu generate                      # FS Routes + Resources 코드 생성
+  bunx mandu generate --force              # 기존 슬롯 덮어쓰기
 
 FS Routes Workflow (권장):
   1. init → 2. app/ 폴더에 page.tsx 생성 → 3. dev → 4. build → 5. start
 
+Resource-Centric Workflow (새로운 방식):
+  1. init → 2. generate resource → 3. Edit slot → 4. generate → 5. dev
+
 Legacy Workflow:
   1. init → 2. spec-upsert → 3. generate → 4. build → 5. guard → 6. dev