@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/skills/erp-kit-module-shared/references/queries.md

@@ -2,13 +2,13 @@
 
 ## Generated Query Shells
 
-Run `erp-kit module generate code` to generate query shells from `docs/queries/*.md`. Each generated shell wraps your `run` function with `defineQuery`.
+Run `erp-kit module generate code -p <path>` to generate query shells from `docs/queries/*.md`. Each generated shell wraps your `run` function with `defineQuery`.
 
 ### Generated shell example
 
 ```typescript
 // @generated — do not edit
-import { defineQuery } from "../../shared/internal";
+import { defineQuery } from "../../../shared";
 import { run } from "./getItem";
 
 export const getItem = defineQuery(run);
@@ -17,7 +17,8 @@ export const getItem = defineQuery(run);
 ### Hand-written implementation
 
 ```typescript
-import type { ReadonlyDB } from "../../shared/internal";
+import type { ReadonlyDB } from "../../../shared";
+import { ok } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type GetItemInput = { id: string } | { sku: string };
@@ -32,42 +33,96 @@ export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
   }
 
   const item = await query.executeTakeFirst();
-  return { item: item ?? null };
+  return ok({ item: item ?? null });
 }
 ```
 
 ## Custom Queries
 
-For queries beyond simple lookups (joins, aggregations, complex filters), write them by hand in `query/*.ts`:
+For queries beyond simple lookups (joins, aggregations, complex filters), write them by hand in `query/*.ts`. List queries must use pagination — see [Paginated List Queries](#paginated-list-queries) for the full pattern.
+
+## Conventions
+
+- `defineQuery` wraps all queries via generated shells
+- `ReadonlyDB<DB>` ensures read-only access
+- All queries return Result types using `ok()` / `err()` from `shared` — consistent with commands
+- Get queries return `ok({ entity: T | null })` using `executeTakeFirst()`
+- List queries return `ok(PaginatedResult<T>)` using pagination utilities — see [Paginated List Queries](#paginated-list-queries)
+- Input types: `type` for union inputs (get), `interface` for single-shape inputs (list)
+- `.generated.ts` files are always overwritten — never edit them
+
+## Paginated List Queries
+
+All list queries use offset/limit pagination via shared utilities. This is the standard for ERP module-level APIs.
+
+### Types
+
+```typescript
+// PaginationInput accepts a generic TOrderBy for per-query sortable fields.
+// "id" is always available as a sort field.
+interface PaginationInput<TOrderBy extends string = never> {
+  limit?: number; // default: 20 (DEFAULT_PAGE_SIZE)
+  offset?: number; // default: 0
+  orderBy?: "id" | TOrderBy; // default: "id"
+  orderDirection?: "asc" | "desc"; // default: "asc"
+}
+
+interface PaginatedResult<T> {
+  items: T[];
+  total?: number; // optional — caller opts in to COUNT(*) overhead
+  hasNextPage: boolean;
+}
+```
+
+### Pattern
+
+1. Extend `PaginationInput<T>` with query-specific sortable fields
+2. Apply `.orderBy()`, `.limit(limit + 1)`, `.offset()` to the Kysely query
+3. Use `buildPaginatedResult(rows, limit)` to build the response — the limit+1 strategy determines `hasNextPage` without a separate count query
 
 ```typescript
-import type { ReadonlyDB } from "../../shared/internal";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
-export interface ListActiveItemsByCategoryInput {
+// Define sortable fields for this query
+type UnitOrderByField = "name" | "symbol" | "createdAt";
+
+export interface ListUnitsByCategoryInput extends PaginationInput<UnitOrderByField> {
   categoryId: string;
 }
 
-export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
-  const items = await db
-    .selectFrom("Item")
+export async function run(db: ReadonlyDB<DB>, input: ListUnitsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  const units = await db
+    .selectFrom("Unit")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
-    .where("status", "=", "ACTIVE")
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
 
-  return { items };
+  return ok(buildPaginatedResult(units, limit));
 }
 ```
 
-## Conventions
+### Rules
 
-- `defineQuery` wraps all queries via generated shells
-- `ReadonlyDB<DB>` ensures read-only access
-- Get queries return `{ entity: T | null }` using `executeTakeFirst()`
-- List queries return `{ entities: T[] }` using `execute()`
-- Input types: `type` for union inputs (get), `interface` for single-shape inputs (list)
-- `.generated.ts` files are always overwritten — never edit them
+- Every list query must extend `PaginationInput` — no unbounded result sets
+- Define a `TOrderBy` type alias with the query's sortable columns (exclude `id` — it's always included)
+- Default sort is `"id" asc` — deterministic ordering is required for stable pagination
+- Use `limit + 1` fetch strategy — never issue a separate `COUNT(*)` unless the caller explicitly needs `total`
+- Queries with no custom sort fields use plain `PaginationInput` (only `"id"` is sortable)
 
 ## Status-Aware Query Rules
 
@@ -86,43 +141,47 @@ Models with a status lifecycle (Stateful models with `status` enum, or simple mo
 
 ```typescript
 // Business use case — status baked into the name
-export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
-  const items = await db
-    .selectFrom("Item")
-    .selectAll()
-    .where("categoryId", "=", input.categoryId)
-    .where("status", "=", "ACTIVE")
-    .execute();
-  return { items };
+// List queries use pagination (see Paginated List Queries section)
+export interface ListActiveItemsByCategoryInput extends PaginationInput {
+  categoryId: string;
 }
 
-// Unfiltered — no status filter, returns everything
-export async function run(db: ReadonlyDB<DB>, input: ListItemsByCategoryInput) {
+export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   const items = await db
     .selectFrom("Item")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
+    .where("status", "=", "ACTIVE")
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
-  return { items };
+  return ok(buildPaginatedResult(items, limit));
 }
 
-// Single lookup — status-unaware, returns any status
+// Single lookup — status-unaware, returns any status (no pagination)
 export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
   const item = await db
     .selectFrom("Item")
     .selectAll()
     .where("id", "=", input.id)
     .executeTakeFirst();
-  return { item: item ?? null };
+  return ok({ item: item ?? null });
 }
 
-// Admin/exploratory — parametric status filter
-export interface SearchItemsInput {
+// Admin/exploratory — parametric status filter with pagination
+export interface SearchItemsInput extends PaginationInput {
   status?: string;
   categoryId?: string;
 }
 
 export async function run(db: ReadonlyDB<DB>, input: SearchItemsInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   let query = db.selectFrom("Item").selectAll();
   if (input.status) {
     query = query.where("status", "=", input.status);
@@ -130,8 +189,12 @@ export async function run(db: ReadonlyDB<DB>, input: SearchItemsInput) {
   if (input.categoryId) {
     query = query.where("categoryId", "=", input.categoryId);
   }
-  const items = await query.execute();
-  return { items };
+  const items = await query
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+  return ok(buildPaginatedResult(items, limit));
 }
 ```
 
@@ -142,14 +205,24 @@ The same naming rules apply. For models using `isActive` instead of a `status` e
 ```typescript
 // Business use case — active units only
 // listActiveUnitsByCategory
+export interface ListActiveUnitsByCategoryInput extends PaginationInput {
+  categoryId: string;
+}
+
 export async function run(db: ReadonlyDB<DB>, input: ListActiveUnitsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   const units = await db
     .selectFrom("Unit")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
     .where("isActive", "=", true)
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
-  return { units };
+  return ok(buildPaginatedResult(units, limit));
 }
 ```
 

package/skills/erp-kit-module-shared/references/structure.md

@@ -1,6 +1,6 @@
 # Module Directory Structure
 
-This structure is automatically scaffolded by `erp-kit module scaffold module <name>`.
+This structure is automatically scaffolded by `erp-kit module init <name> <dir>`.
 
 ```
 {module}/

package/skills/erp-kit-module-shared/references/testing.md

@@ -29,6 +29,16 @@ For commands with generic `CF`, add one test verifying custom fields reach `.val
 - Assert with `spies.values`: `expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ myField: "value" }))`
 - Use `toHaveBeenNthCalledWith(n, ...)` when multiple inserts occur (e.g., audit events)
 
+## Test Case Documentation Sync
+
+Command and query docs include a `## Test Cases` section listing each `it()` description. This list must stay in sync with the actual test file:
+
+- Each `it("...")` in the test file must appear as `- ...` in the doc's `## Test Cases`
+- Each item in `## Test Cases` must have a corresponding `it()` in the test file
+- Run `erp-kit module sync-check` to verify alignment
+- When adding a new test, add the `it()` description to the doc first, then write the test
+- Test case descriptions should match the doc's Process Flow branches and Error Scenarios
+
 ## Fixtures (`testing/fixtures.ts`)
 
 - Import `Schema` from `lib/types` (not `Namespace` from generated code)

package/skills/erp-kit-update/SKILL.md

@@ -19,8 +19,8 @@ Ask the user:
 
 1. **What changed?** (free-text description of the change)
 2. **Where?** Determine domain from the target:
-   - `examples/<app>/` → **App workflow** (skills matching `erp-kit-app-*`)
-   - `modules/<module>/` → **Module workflow** (skills matching `erp-kit-module-*`)
+   - App directory (e.g., `{APP_ROOT}/{APP_NAME}/`) → **App workflow** (skills matching `erp-kit-app-*`)
+   - Module directory (e.g., `{MODULE_ROOT}/{MODULE_NAME}/`) → **Module workflow** (skills matching `erp-kit-module-*`)
 
 If the user names a specific app or module, confirm the path. If ambiguous, check both directories.
 
@@ -31,7 +31,7 @@ Dynamically discover available erp-kit skills:
 1. Glob for `erp-kit-app-*/SKILL.md` or `erp-kit-module-*/SKILL.md` files (based on domain from Phase 1) in the skills directory
 2. Read each SKILL.md's frontmatter `name` and `description`
 3. Skip `erp-kit-module-shared` (not directly invocable)
-4. Sort skills by their numeric step (extract number from name, e.g. `erp-kit-app-2-breakdown` → step 2)
+4. Sort skills by their numeric step (extract number from name, e.g. `erp-kit-app-3-plan` → step 3)
 
 This builds the routing table at runtime — new or renamed skills are picked up automatically.
 
@@ -53,7 +53,7 @@ Only list downstream skills that are plausibly affected by the change.
 
 Use the `Skill` tool to invoke the routed skill. Pass the app or module name as the argument.
 
-Example: `Skill: erp-kit-app-2-breakdown, args: "inventory-management"`
+Example: `Skill: erp-kit-app-3-plan, args: "inventory-management"`
 
 ## Multiple Changes
 

package/src/app.ts

@@ -1 +1 @@
-export { createContext } from "./modules/shared/createContext";
+export { createContext } from "./shared/createContext";

package/src/commands/app/index.ts

@@ -1,14 +1,17 @@
+import path from "node:path";
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
 import { runCheck } from "../check";
 import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
-import { runScaffold, APP_TYPES, type ScaffoldType } from "../scaffold";
+import { runGenerateDoc, APP_DOC_TYPES, type DocType } from "../generate-doc";
+import { runGenerateAppCode } from "../../generator/generate-code";
+import { runInitAppWithReadme } from "../init-module";
 
 const cwd = process.cwd();
 
-const rootArgs = z.object({
-  root: arg(z.string(), {
-    alias: "r",
+const pathArgs = z.object({
+  path: arg(z.string(), {
+    alias: "p",
     description: "Path to app-compose directory",
   }),
 });
@@ -16,9 +19,9 @@ const rootArgs = z.object({
 const checkCommand = defineCommand({
   name: "check",
   description: "Validate app docs against schemas",
-  args: rootArgs,
+  args: pathArgs,
   run: async (args) => {
-    const exitCode = await runCheck({ appRoot: args.root }, cwd);
+    const exitCode = await runCheck({ appRoot: args.path }, cwd);
     process.exit(exitCode);
   },
 });
@@ -26,25 +29,40 @@ const checkCommand = defineCommand({
 const syncCheckCommand = defineCommand({
   name: "sync-check",
   description: "Validate source <-> doc correspondence",
-  args: rootArgs,
+  args: pathArgs,
   run: async (args) => {
-    const result = await runSyncCheck({ appRoot: args.root }, cwd);
+    const result = await runSyncCheck({ appRoot: args.path }, cwd);
     console.log(formatSyncCheckReport(result));
     process.exit(result.exitCode);
   },
 });
 
-const scaffoldCommand = defineCommand({
-  name: "scaffold",
-  description: "Generate app doc from schema template",
-  args: rootArgs.extend({
-    type: arg(z.enum(APP_TYPES as unknown as [string, ...string[]]), {
+const initCommand = defineCommand({
+  name: "init",
+  description: "Bootstrap a new app with directory structure and README",
+  args: z.object({
+    name: arg(z.string(), {
       positional: true,
-      description: `Scaffold type (${APP_TYPES.join(", ")})`,
+      description: "App name",
     }),
-    parent: arg(z.string(), {
+    dir: arg(z.string(), {
       positional: true,
-      description: "App name",
+      description: "Parent directory where the app will be created",
+    }),
+  }),
+  run: async (args) => {
+    const exitCode = await runInitAppWithReadme(args.name, args.dir, cwd);
+    process.exit(exitCode);
+  },
+});
+
+const docCommand = defineCommand({
+  name: "doc",
+  description: "Create a documentation file from a schema template",
+  args: pathArgs.extend({
+    type: arg(z.enum(APP_DOC_TYPES as unknown as [string, ...string[]]), {
+      positional: true,
+      description: `Doc type (${APP_DOC_TYPES.join(", ")})`,
     }),
     name: arg(z.string().optional(), {
       positional: true,
@@ -52,23 +70,38 @@ const scaffoldCommand = defineCommand({
     }),
   }),
   run: async (args) => {
-    const exitCode = await runScaffold(
-      args.type as ScaffoldType,
-      args.parent,
-      args.name,
-      args.root,
-      cwd,
-    );
+    const exitCode = await runGenerateDoc(args.type as DocType, args.name, args.path, cwd);
+    process.exit(exitCode);
+  },
+});
+
+const codeCommand = defineCommand({
+  name: "code",
+  description: "Generate boilerplate source files from docs",
+  args: pathArgs,
+  run: (args) => {
+    const appPath = path.resolve(cwd, args.path);
+    const exitCode = runGenerateAppCode(appPath);
     process.exit(exitCode);
   },
 });
 
+const generateCommand = defineCommand({
+  name: "generate",
+  description: "Generate docs and code for an app",
+  subCommands: {
+    doc: docCommand,
+    code: codeCommand,
+  },
+});
+
 export const appCommand = defineCommand({
   name: "app",
   description: "App-compose management",
   subCommands: {
     check: checkCommand,
     "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
+    init: initCommand,
+    generate: generateCommand,
   },
 });

package/src/commands/check.ts

@@ -25,7 +25,7 @@ export function buildCheckTargets(config: {
   if (config.appRoot) {
     const a = config.appRoot;
     targets.push(
-      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
+      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "app" },
       { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
       { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
       { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },

package/src/commands/generate-doc.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { resolveDocPath } from "./generate-doc";
+
+describe("resolveDocPath", () => {
+  it("resolves command doc path", () => {
+    const result = resolveDocPath("command", "CreateOrder", "modules/inventory");
+    expect(result).toBe("modules/inventory/docs/commands/CreateOrder.md");
+  });
+
+  it("resolves feature doc path", () => {
+    const result = resolveDocPath("feature", "stock-tracking", "modules/inventory");
+    expect(result).toBe("modules/inventory/docs/features/stock-tracking.md");
+  });
+
+  it("resolves model doc path", () => {
+    const result = resolveDocPath("model", "StockItem", "modules/inventory");
+    expect(result).toBe("modules/inventory/docs/models/StockItem.md");
+  });
+
+  it("resolves query doc path", () => {
+    const result = resolveDocPath("query", "ConvertQuantity", "modules/inventory");
+    expect(result).toBe("modules/inventory/docs/queries/ConvertQuantity.md");
+  });
+
+  it("resolves actors doc path", () => {
+    const result = resolveDocPath("actors", "admin", "examples/my-app");
+    expect(result).toBe("examples/my-app/docs/actors/admin.md");
+  });
+
+  it("resolves business-flow doc path", () => {
+    const result = resolveDocPath("business-flow", "onboarding", "examples/my-app");
+    expect(result).toBe("examples/my-app/docs/business-flow/onboarding/README.md");
+  });
+
+  it("resolves story doc path with flow/name format", () => {
+    const result = resolveDocPath("story", "onboarding/admin--create-user", "examples/my-app");
+    expect(result).toBe(
+      "examples/my-app/docs/business-flow/onboarding/story/admin--create-user.md",
+    );
+  });
+
+  it("resolves screen doc path", () => {
+    const result = resolveDocPath("screen", "supplier-list", "examples/my-app");
+    expect(result).toBe("examples/my-app/docs/screen/supplier-list.md");
+  });
+
+  it("resolves resolver doc path", () => {
+    const result = resolveDocPath("resolver", "create-supplier", "examples/my-app");
+    expect(result).toBe("examples/my-app/docs/resolver/create-supplier.md");
+  });
+
+  it("throws when name is missing", () => {
+    expect(() => resolveDocPath("command", undefined, "modules/inventory")).toThrow(
+      "Name is required",
+    );
+  });
+
+  it("throws when story name is not flow/name format", () => {
+    expect(() => resolveDocPath("story", "bad-name", "examples/my-app")).toThrow(
+      "Story name must be",
+    );
+  });
+});

package/src/commands/generate-doc.ts

@@ -0,0 +1,98 @@
+import path from "node:path";
+import fs from "node:fs";
+import { runMdschema } from "../mdschema";
+import { ALL_SCHEMAS } from "../schemas";
+
+export const MODULE_DOC_TYPES = ["feature", "command", "model", "query"] as const;
+export const APP_DOC_TYPES = ["actors", "business-flow", "story", "screen", "resolver"] as const;
+export const ALL_DOC_TYPES = [...MODULE_DOC_TYPES, ...APP_DOC_TYPES] as const;
+
+export type DocType = (typeof ALL_DOC_TYPES)[number];
+
+const MODULE_DIR_MAP: Record<string, string> = {
+  feature: "docs/features",
+  command: "docs/commands",
+  model: "docs/models",
+  query: "docs/queries",
+};
+
+const APP_DIR_MAP: Record<string, string> = {
+  actors: "docs/actors",
+  "business-flow": "docs/business-flow",
+  screen: "docs/screen",
+  resolver: "docs/resolver",
+};
+
+export function resolveDocPath(
+  type: DocType,
+  name: string | undefined,
+  modulePath: string,
+): string {
+  if (!name) {
+    throw new Error(`Name is required for doc type "${type}"`);
+  }
+
+  if (type === "business-flow") {
+    return path.join(modulePath, "docs/business-flow", name, "README.md");
+  }
+
+  if (type === "story") {
+    const parts = name.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`,
+      );
+    }
+    return path.join(modulePath, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+  }
+
+  if (MODULE_DIR_MAP[type]) {
+    return path.join(modulePath, MODULE_DIR_MAP[type], `${name}.md`);
+  }
+
+  if (APP_DIR_MAP[type]) {
+    return path.join(modulePath, APP_DIR_MAP[type], `${name}.md`);
+  }
+
+  throw new Error(`Unknown doc type: ${type}`);
+}
+
+export async function runGenerateDoc(
+  type: DocType,
+  name: string | undefined,
+  modulePath: string,
+  cwd: string,
+): Promise<number> {
+  const outputPath = resolveDocPath(type, name, modulePath);
+  const absoluteOutput = path.resolve(cwd, outputPath);
+
+  if (fs.existsSync(absoluteOutput)) {
+    console.error(`File already exists: ${outputPath}`);
+    return 1;
+  }
+
+  const schemaPath = ALL_SCHEMAS[type];
+  if (!schemaPath) {
+    console.error(`No schema found for type: ${type}`);
+    return 2;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+  } catch (err) {
+    console.error(
+      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return 1;
+  }
+
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
+    cwd,
+  );
+
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+
+  return exitCode;
+}

package/src/commands/index.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
 import { runInit } from "./init";
+import { runUpdate } from "./update";
 import { runLicenseCheck, runLicenseList } from "./license";
 import { moduleCommand } from "./module/index";
 import { appCommand } from "./app/index";
@@ -14,15 +15,24 @@ const cwd = process.cwd();
 
 export const initCommand = defineCommand({
   name: "init",
-  description: "Set up consumer repo with framework skills",
+  description: "First-time setup for a consumer repo",
+  run: () => {
+    const exitCode = runInit(cwd);
+    process.exit(exitCode);
+  },
+});
+
+export const updateCommand = defineCommand({
+  name: "update",
+  description: "Refresh framework-managed resources (skills, workflows)",
   args: z.object({
-    force: arg(z.boolean().default(false), {
-      alias: "f",
-      description: "Overwrite existing skills",
+    resources: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Resources to update (skills, workflows). Defaults to all.",
     }),
   }),
   run: (args) => {
-    const exitCode = runInit(cwd, args.force);
+    const exitCode = runUpdate(cwd, args.resources);
     process.exit(exitCode);
   },
 });
@@ -68,6 +78,7 @@ export const mainCommand = defineCommand({
     app: appCommand,
     mock: mockCommand,
     init: initCommand,
+    update: updateCommand,
     license: licenseCommand,
   },
 });