@tailor-platform/erp-kit 0.1.0 → 0.1.2

package/src/commands/init.test.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { runInit } from "./init.js";
 
@@ -21,6 +21,22 @@ describe("runInit", () => {
     expect(fs.existsSync(skillPath)).toBe(true);
   });
 
+  it("copies skill references/ directories", () => {
+    runInit(tmpDir, false);
+    const refPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "4-module-tdd-implementation",
+      "references",
+      "models.md",
+    );
+    expect(fs.existsSync(refPath)).toBe(true);
+
+    const content = fs.readFileSync(refPath, "utf-8");
+    expect(content).toContain("# Database Models");
+  });
+
   it("does not overwrite project-specific skills", () => {
     const customSkillDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
     fs.mkdirSync(customSkillDir, { recursive: true });
@@ -48,30 +64,25 @@ describe("runInit", () => {
     expect(content).not.toBe("# Customized");
   });
 
-  it("copies framework rules to .agents/rules/", () => {
+  it("creates .claude/skills symlink to .agents/skills", () => {
     runInit(tmpDir, false);
-    const rulePath = path.join(tmpDir, ".agents", "rules", "module-development", "structure.md");
-    expect(fs.existsSync(rulePath)).toBe(true);
-    // Also check nested subdirectory
-    const nestedRule = path.join(tmpDir, ".agents", "rules", "app-compose", "frontend", "auth.md");
-    expect(fs.existsSync(nestedRule)).toBe(true);
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(true);
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
   });
 
-  it("does not overwrite existing rules", () => {
-    const ruleDir = path.join(tmpDir, ".agents", "rules", "module-development");
-    fs.mkdirSync(ruleDir, { recursive: true });
-    fs.writeFileSync(path.join(ruleDir, "structure.md"), "# Custom Rule");
+  it("skips symlink when .claude/skills is a real directory", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(claudeSkills, { recursive: true });
     runInit(tmpDir, false);
-    const content = fs.readFileSync(path.join(ruleDir, "structure.md"), "utf-8");
-    expect(content).toBe("# Custom Rule");
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
   });
 
-  it("overwrites existing rules with --force", () => {
-    const ruleDir = path.join(tmpDir, ".agents", "rules", "module-development");
-    fs.mkdirSync(ruleDir, { recursive: true });
-    fs.writeFileSync(path.join(ruleDir, "structure.md"), "# Custom Rule");
+  it("relinks symlink with --force when target differs", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+    fs.symlinkSync("../old-target", claudeSkills);
     runInit(tmpDir, true);
-    const content = fs.readFileSync(path.join(ruleDir, "structure.md"), "utf-8");
-    expect(content).not.toBe("# Custom Rule");
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
   });
 });

package/src/commands/init.ts

@@ -4,7 +4,6 @@ import chalk from "chalk";
 import { PACKAGE_ROOT } from "../util.js";
 
 const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
-const RULES_SRC = path.join(PACKAGE_ROOT, "rules");
 
 const FRAMEWORK_SKILLS = [
   "1-module-docs",
@@ -21,65 +20,99 @@ const FRAMEWORK_SKILLS = [
   "mock-scenario",
 ];
 
+function copyDirectoryRecursive(
+  srcDir: string,
+  destDir: string,
+  force: boolean,
+): { copied: number; skipped: number } {
+  let copied = 0;
+  let skipped = 0;
+
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      const sub = copyDirectoryRecursive(srcPath, destPath, force);
+      copied += sub.copied;
+      skipped += sub.skipped;
+    } else {
+      if (!force && fs.existsSync(destPath)) {
+        skipped++;
+        continue;
+      }
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+
+  return { copied, skipped };
+}
+
 export function runInit(cwd: string, force: boolean): number {
   console.log(chalk.bold("erp-kit init\n"));
 
+  // --- Skills ---
   const skillsDest = path.join(cwd, ".agents", "skills");
   let copiedCount = 0;
   let skippedCount = 0;
   for (const skill of FRAMEWORK_SKILLS) {
-    const srcSkill = path.join(SKILLS_SRC, skill, "SKILL.md");
+    const srcSkillDir = path.join(SKILLS_SRC, skill);
+    if (!fs.existsSync(srcSkillDir)) continue;
+
     const destDir = path.join(skillsDest, skill);
-    const destSkill = path.join(destDir, "SKILL.md");
+    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
+    copiedCount += result.copied;
 
-    if (!fs.existsSync(srcSkill)) continue;
-    if (!force && fs.existsSync(destSkill)) {
-      console.log(chalk.yellow(`  Skipped ${skill}/SKILL.md (already exists)`));
-      skippedCount++;
-      continue;
+    if (result.skipped > 0) {
+      console.log(chalk.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
+      skippedCount += result.skipped;
     }
-
-    fs.mkdirSync(destDir, { recursive: true });
-    fs.copyFileSync(srcSkill, destSkill);
-    copiedCount++;
   }
-  console.log(chalk.green(`  Copied ${copiedCount} framework skills to .agents/skills/`));
+  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
   if (skippedCount > 0) {
     console.log(
-      chalk.yellow(`  Skipped ${skippedCount} existing skills (use --force to overwrite)`),
+      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`),
     );
   }
 
-  const rulesDest = path.join(cwd, ".agents", "rules");
-  let rulesCount = 0;
-  let rulesSkipped = 0;
-  if (fs.existsSync(RULES_SRC)) {
-    const copyRulesRecursive = (srcDir: string, destDir: string) => {
-      for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-        const srcPath = path.join(srcDir, entry.name);
-        const destPath = path.join(destDir, entry.name);
-        if (entry.isDirectory()) {
-          copyRulesRecursive(srcPath, destPath);
-        } else {
-          if (!force && fs.existsSync(destPath)) {
-            const rel = path.relative(rulesDest, destPath);
-            console.log(chalk.yellow(`  Skipped rule ${rel} (already exists)`));
-            rulesSkipped++;
-            continue;
-          }
-          fs.mkdirSync(destDir, { recursive: true });
-          fs.copyFileSync(srcPath, destPath);
-          rulesCount++;
-        }
+  // --- Claude Code symlink ---
+  const claudeSkills = path.join(cwd, ".claude", "skills");
+  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+
+  // lstatSync doesn't follow symlinks, so dangling symlinks are detected
+  const claudeSkillsExists = (() => {
+    try {
+      fs.lstatSync(claudeSkills);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+
+  if (claudeSkillsExists) {
+    const stat = fs.lstatSync(claudeSkills);
+    if (stat.isSymbolicLink()) {
+      const current = fs.readlinkSync(claudeSkills);
+      if (current === relTarget) {
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (already linked)"));
+      } else if (force) {
+        fs.unlinkSync(claudeSkills);
+        fs.symlinkSync(relTarget, claudeSkills);
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (relinked)"));
+      } else {
+        console.log(
+          chalk.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`),
+        );
       }
-    };
-    copyRulesRecursive(RULES_SRC, rulesDest);
-  }
-  console.log(chalk.green(`  Copied ${rulesCount} framework rules to .agents/rules/`));
-  if (rulesSkipped > 0) {
-    console.log(
-      chalk.yellow(`  Skipped ${rulesSkipped} existing rules (use --force to overwrite)`),
-    );
+    } else {
+      console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
+    }
+  } else {
+    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+    fs.symlinkSync(relTarget, claudeSkills);
+    console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
   }
 
   console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));

package/src/commands/module/index.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+import { runCheck } from "../check.js";
+import { runSyncCheck, formatSyncCheckReport } from "../sync-check.js";
+import { runScaffold, MODULE_TYPES, type ScaffoldType } from "../scaffold.js";
+import { runModuleList } from "./list.js";
+
+const cwd = process.cwd();
+
+const rootArgs = z.object({
+  root: arg(z.string(), {
+    alias: "r",
+    description: "Path to modules directory",
+  }),
+});
+
+const listCommand = defineCommand({
+  name: "list",
+  description: "List available modules",
+  run: () => {
+    const exitCode = runModuleList();
+    process.exit(exitCode);
+  },
+});
+
+const checkCommand = defineCommand({
+  name: "check",
+  description: "Validate module docs against schemas",
+  args: rootArgs,
+  run: async (args) => {
+    const exitCode = await runCheck({ modulesRoot: args.root }, cwd);
+    process.exit(exitCode);
+  },
+});
+
+const syncCheckCommand = defineCommand({
+  name: "sync-check",
+  description: "Validate source <-> doc correspondence",
+  args: rootArgs,
+  run: async (args) => {
+    const result = await runSyncCheck({ modulesRoot: args.root }, cwd);
+    console.log(formatSyncCheckReport(result));
+    process.exit(result.exitCode);
+  },
+});
+
+const scaffoldCommand = defineCommand({
+  name: "scaffold",
+  description: "Generate module doc from schema template",
+  args: rootArgs.extend({
+    type: arg(z.enum(MODULE_TYPES as unknown as [string, ...string[]]), {
+      positional: true,
+      description: `Scaffold type (${MODULE_TYPES.join(", ")})`,
+    }),
+    parent: arg(z.string(), {
+      positional: true,
+      description: "Module name",
+    }),
+    name: arg(z.string().optional(), {
+      positional: true,
+      description: "Item name (required for feature, command, model)",
+    }),
+  }),
+  run: async (args) => {
+    const exitCode = await runScaffold(
+      args.type as ScaffoldType,
+      args.parent,
+      args.name,
+      args.root,
+      cwd,
+    );
+    process.exit(exitCode);
+  },
+});
+
+export const moduleCommand = defineCommand({
+  name: "module",
+  description: "Module management",
+  subCommands: {
+    list: listCommand,
+    check: checkCommand,
+    "sync-check": syncCheckCommand,
+    scaffold: scaffoldCommand,
+  },
+});

package/src/commands/module/list.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+
+describe("listModules", () => {
+  it("returns the built-in modules with counts", async () => {
+    const { listModules } = await import("./list.js");
+    const modules = listModules();
+    expect(modules.length).toBeGreaterThan(0);
+
+    const primitives = modules.find((m) => m.name === "primitives");
+    expect(primitives).toBeDefined();
+    expect(primitives!.commands).toBeGreaterThan(0);
+    expect(primitives!.models).toBeGreaterThan(0);
+    expect(primitives!.features).toBeGreaterThan(0);
+  });
+
+  it("returns zero counts for stub modules", async () => {
+    const { listModules } = await import("./list.js");
+    const modules = listModules();
+    const inventory = modules.find((m) => m.name === "inventory");
+    expect(inventory).toBeDefined();
+    expect(inventory!.commands).toBe(0);
+    expect(inventory!.models).toBe(0);
+    expect(inventory!.features).toBe(0);
+  });
+
+  it("excludes shared and testing directories", async () => {
+    const { listModules } = await import("./list.js");
+    const modules = listModules();
+    const names = modules.map((m) => m.name);
+    expect(names).not.toContain("shared");
+    expect(names).not.toContain("testing");
+  });
+
+  it("returns modules in alphabetical order", async () => {
+    const { listModules } = await import("./list.js");
+    const modules = listModules();
+    const names = modules.map((m) => m.name);
+    const sorted = [...names].sort();
+    expect(names).toEqual(sorted);
+  });
+});
+
+describe("formatModuleList", () => {
+  it("formats modules with counts", async () => {
+    const { formatModuleList } = await import("./list.js");
+    const output = formatModuleList([
+      { name: "primitives", commands: 14, models: 4, features: 4 },
+      { name: "inventory", commands: 0, models: 0, features: 0 },
+    ]);
+    expect(output).toContain("primitives");
+    expect(output).toContain("14 commands");
+    expect(output).toContain("4 models");
+    expect(output).toContain("4 features");
+    expect(output).toContain("inventory");
+    expect(output).toContain("2 modules");
+  });
+
+  it("handles empty list", async () => {
+    const { formatModuleList } = await import("./list.js");
+    expect(formatModuleList([])).toBe("No modules found.");
+  });
+});

package/src/commands/module/list.ts

@@ -0,0 +1,64 @@
+import { readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { PACKAGE_ROOT } from "../../util.js";
+
+const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
+const EXCLUDED_DIRS = new Set(["shared", "testing"]);
+
+export interface ModuleInfo {
+  name: string;
+  commands: number;
+  models: number;
+  features: number;
+}
+
+function countFiles(dir: string, pattern: RegExp, exclusions: RegExp[]): number {
+  if (!existsSync(dir)) return 0;
+  return readdirSync(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f)))
+    .length;
+}
+
+export function listModules(): ModuleInfo[] {
+  if (!existsSync(MODULES_DIR)) return [];
+  return readdirSync(MODULES_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name))
+    .map((d) => {
+      const modDir = join(MODULES_DIR, d.name);
+      return {
+        name: d.name,
+        commands: countFiles(join(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
+        models: countFiles(join(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
+        features: countFiles(join(modDir, "docs", "features"), /\.md$/, []),
+      };
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function formatModuleList(modules: ModuleInfo[]): string {
+  if (modules.length === 0) return "No modules found.";
+
+  const lines: string[] = [];
+  lines.push(chalk.bold("Modules:\n"));
+
+  const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
+
+  for (const mod of modules) {
+    const counts = [
+      `${mod.commands} commands`,
+      `${mod.models} models`,
+      `${mod.features} features`,
+    ].join(", ");
+    lines.push(`  ${mod.name.padEnd(nameWidth)}  ${counts}`);
+  }
+
+  lines.push("");
+  lines.push(`${modules.length} modules`);
+  return lines.join("\n");
+}
+
+export function runModuleList(): number {
+  const modules = listModules();
+  console.log(formatModuleList(modules));
+  return 0;
+}

package/src/commands/scaffold.test.ts

@@ -61,6 +61,11 @@ describe("resolveScaffoldPath", () => {
     expect(result).toBe("examples/my-app/docs/resolver/create-supplier.md");
   });
 
+  it("resolves query scaffold path", () => {
+    const result = resolveScaffoldPath("query", "inventory", "ConvertQuantity", "modules");
+    expect(result).toBe("modules/inventory/docs/queries/ConvertQuantity.md");
+  });
+
   // Validation
   it("throws when name is required but missing", () => {
     expect(() => resolveScaffoldPath("command", "inventory", undefined, "modules")).toThrow(

package/src/commands/scaffold.ts

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import { runMdschema } from "../mdschema.js";
 import { ALL_SCHEMAS } from "../schemas.js";
 
-export const MODULE_TYPES = ["module", "feature", "command", "model"] as const;
+export const MODULE_TYPES = ["module", "feature", "command", "model", "query"] as const;
 export const APP_TYPES = [
   "requirements",
   "actors",
@@ -20,6 +20,7 @@ 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> = {

package/src/commands/sync-check.test.ts

@@ -103,6 +103,34 @@ describe("runSyncCheck", () => {
     expect(result.summary.totalSources).toBe(1);
   });
 
+  it("reports missing doc for query source without doc", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "query");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "convertAmount.ts"), "export {}");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({
+        type: "missing-doc",
+        category: "query",
+        expectedBasename: "convertamount",
+      }),
+    );
+  });
+
+  it("returns 0 when query source and doc match", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "query");
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "queries");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "convertAmount.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "convertAmount.md"), "# ConvertAmount");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+  });
+
   it("checks only module patterns when appRoot is not set", async () => {
     const resolverSrcDir = path.join(
       tmpDir,

package/src/commands/sync-check.ts

@@ -41,6 +41,12 @@ function moduleCategories(root: string): CategoryConfig[] {
       docPattern: `${root}/*/docs/models/*.md`,
       exclusions: [/\.test\.ts$/, /^index\.ts$/],
     },
+    {
+      name: "query",
+      sourcePattern: `${root}/*/query/*.ts`,
+      docPattern: `${root}/*/docs/queries/*.md`,
+      exclusions: [/\.test\.ts$/],
+    },
   ];
 }
 

package/src/integration.test.ts

@@ -11,13 +11,11 @@ const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
 const skipReason = fs.existsSync(CLI_PATH) ? undefined : "Run `pnpm build` first";
 
 describe.skipIf(skipReason)("integration", () => {
-  it("check command runs against sdk-plugins modules", () => {
-    // mdschema may report validation errors in real docs, so we allow non-zero exit codes
-    // but verify the CLI itself doesn't crash with an unexpected error
+  it("module check command runs against sdk-plugins modules", () => {
     try {
       const result = execFileSync(
         "node",
-        [CLI_PATH, "check", "--modules-root", "packages/erp-kit/src/modules"],
+        [CLI_PATH, "module", "check", "--root", "packages/erp-kit/src/modules"],
         {
           cwd: REPO_ROOT,
           encoding: "utf-8",
@@ -33,11 +31,11 @@ describe.skipIf(skipReason)("integration", () => {
     }
   });
 
-  it("sync-check command runs against sdk-plugins modules", () => {
+  it("module sync-check command runs against sdk-plugins modules", () => {
     try {
       const result = execFileSync(
         "node",
-        [CLI_PATH, "sync-check", "--modules-root", "packages/erp-kit/src/modules"],
+        [CLI_PATH, "module", "sync-check", "--root", "packages/erp-kit/src/modules"],
         {
           cwd: REPO_ROOT,
           encoding: "utf-8",
@@ -57,7 +55,7 @@ describe.skipIf(skipReason)("integration", () => {
       encoding: "utf-8",
     });
     expect(result).toContain("erp-kit");
-    expect(result).toContain("check");
-    expect(result).toContain("scaffold");
+    expect(result).toContain("module");
+    expect(result).toContain("app");
   });
 });

package/src/module.ts

@@ -1,9 +1,10 @@
 // shared/internal
 export { defineCommand, type Command } from "./modules/shared/defineCommand";
+export { defineQuery, type Query } from "./modules/shared/defineQuery";
 export { definePermissions } from "./modules/shared/definePermissions";
 export { requirePermission } from "./modules/shared/requirePermission";
 export { createDomainError, InsufficientPermissionError } from "./modules/shared/errors";
-export type { CommandContext } from "./modules/shared/types";
+export type { CommandContext, QueryContext, ReadonlyDB } from "./modules/shared/types";
 export type {
   InferSchema,
   Selectable,
@@ -43,13 +44,13 @@ export {
   SameCurrencyPairError,
   InvalidExchangeRateError,
 } from "./modules/primitives/lib/errors";
-export { type ConvertQuantityInput } from "./modules/primitives/command/convertQuantity";
+export { type ConvertQuantityInput } from "./modules/primitives/query/convertQuantity";
 export { type ActivateCategoryInput } from "./modules/primitives/command/activateCategory";
 export { type DeactivateCategoryInput } from "./modules/primitives/command/deactivateCategory";
 export { type SetReferenceUnitInput } from "./modules/primitives/command/setReferenceUnit";
 export { type ActivateUnitInput } from "./modules/primitives/command/activateUnit";
 export { type DeactivateUnitInput } from "./modules/primitives/command/deactivateUnit";
-export { type ConvertAmountInput } from "./modules/primitives/command/convertAmount";
+export { type ConvertAmountInput } from "./modules/primitives/query/convertAmount";
 export { type ActivateCurrencyInput } from "./modules/primitives/command/activateCurrency";
 export { type DeactivateCurrencyInput } from "./modules/primitives/command/deactivateCurrency";
 export { type SetBaseCurrencyInput } from "./modules/primitives/command/setBaseCurrency";

package/src/modules/primitives/docs/models/Currency.md

@@ -29,6 +29,10 @@ stateDiagram-v2
 - [deactivateCurrency](../commands/DeactivateCurrency.md)
 - [setBaseCurrency](../commands/SetBaseCurrency.md)
 
+### Query Definitions
+
+- [convertAmount](../queries/ConvertAmount.md)
+
 ### Models
 
 - Currency

package/src/modules/primitives/docs/models/ExchangeRate.md

@@ -15,7 +15,10 @@ AppendOnly
 ### Command Definitions
 
 - [createExchangeRate](../commands/CreateExchangeRate.md)
-- [convertAmount](../commands/ConvertAmount.md)
+
+### Query Definitions
+
+- [convertAmount](../queries/ConvertAmount.md)
 
 ### Models
 

package/src/modules/primitives/docs/models/Unit.md

@@ -27,7 +27,10 @@ stateDiagram-v2
 - [createUnit](../commands/CreateUnit.md)
 - [activateUnit](../commands/ActivateUnit.md)
 - [deactivateUnit](../commands/DeactivateUnit.md)
-- [convertQuantity](../commands/ConvertQuantity.md)
+
+### Query Definitions
+
+- [convertQuantity](../queries/ConvertQuantity.md)
 
 ### Models
 

package/src/modules/primitives/docs/models/UoMCategory.md

@@ -28,6 +28,8 @@ stateDiagram-v2
 - [deactivateCategory](../commands/DeactivateCategory.md)
 - [setReferenceUnit](../commands/SetReferenceUnit.md)
 
+### Query Definitions
+
 ### Models
 
 - UoMCategory

package/src/modules/primitives/index.ts

@@ -28,13 +28,13 @@ export {
 } from "./lib/errors";
 
 // input types
-export { type ConvertQuantityInput } from "./command/convertQuantity";
+export { type ConvertQuantityInput } from "./query/convertQuantity";
 export { type ActivateCategoryInput } from "./command/activateCategory";
 export { type DeactivateCategoryInput } from "./command/deactivateCategory";
 export { type SetReferenceUnitInput } from "./command/setReferenceUnit";
 export { type ActivateUnitInput } from "./command/activateUnit";
 export { type DeactivateUnitInput } from "./command/deactivateUnit";
-export { type ConvertAmountInput } from "./command/convertAmount";
+export { type ConvertAmountInput } from "./query/convertAmount";
 export { type ActivateCurrencyInput } from "./command/activateCurrency";
 export { type DeactivateCurrencyInput } from "./command/deactivateCurrency";
 export { type SetBaseCurrencyInput } from "./command/setBaseCurrency";