@anatolykoptev/krolik-cli 0.10.1 → 0.12.0

package/dist/bin/cli.js

@@ -56,7 +56,7 @@ var KROLIK_VERSION, TEMPLATE_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     init_esm_shims();
-    KROLIK_VERSION = "0.10.1";
+    KROLIK_VERSION = "0.12.0";
     TEMPLATE_VERSION = "6.1.0";
   }
 });
@@ -13289,18 +13289,33 @@ var init_routes2 = __esm({
     init_esm_shims();
     init_core();
     routesFlagSchema = {
-      json: COMMON_FLAGS.json
+      json: COMMON_FLAGS.json,
+      compact: { flag: "--compact" },
+      full: { flag: "--full" }
     };
     routesTool = {
       name: "krolik_routes",
-      description: "Analyze tRPC API routes. Returns all procedures with types, inputs, and protection status.",
+      description: `Analyze tRPC API routes. Returns all procedures with types and protection status.
+
+**Output modes:**
+- (default) Smart format - groups procedures by type (queries/mutations), shows only unprotected as exceptions
+- compact: true - overview only, routers with Q/M counts (smallest output)
+- full: true - verbose legacy format with all procedure attributes`,
       inputSchema: {
         type: "object",
         properties: {
           ...PROJECT_PROPERTY,
           json: {
             type: "boolean",
-            description: "Return JSON format instead of markdown"
+            description: "Return JSON format instead of XML"
+          },
+          compact: {
+            type: "boolean",
+            description: "Compact output - routers with procedure counts only. Smallest output."
+          },
+          full: {
+            type: "boolean",
+            description: "Full verbose output - all procedures with all attributes. Use only when you need complete details."
           }
         }
       },
@@ -13325,18 +13340,47 @@ var init_schema2 = __esm({
     init_esm_shims();
     init_core();
     schemaFlagSchema = {
-      json: COMMON_FLAGS.json
+      json: COMMON_FLAGS.json,
+      model: { flag: "--model" },
+      domain: { flag: "--domain" },
+      compact: { flag: "--compact" },
+      full: { flag: "--full" }
     };
     schemaTool = {
       name: "krolik_schema",
-      description: "Analyze Prisma database schema. Returns all models, fields, relations, and enums.",
+      description: `Analyze Prisma database schema. Returns models, fields, relations, and enums.
+
+**Output modes:**
+- (default) Smart format - AI-optimized, hides standard fields (id, createdAt, updatedAt), obvious defaults
+- compact: true - overview only, models with relations (smallest output)
+- full: true - verbose legacy format with all fields and attributes
+
+**Filters:**
+- model: "User" - filter by model name (partial match)
+- domain: "Auth" - filter by domain (derived from schema filename)`,
       inputSchema: {
         type: "object",
         properties: {
           ...PROJECT_PROPERTY,
           json: {
             type: "boolean",
-            description: "Return JSON format instead of markdown"
+            description: "Return JSON format instead of XML"
+          },
+          model: {
+            type: "string",
+            description: 'Filter by model name (partial match, case-insensitive). Example: "User", "Booking"'
+          },
+          domain: {
+            type: "string",
+            description: 'Filter by domain (derived from schema filename). Example: "Auth", "Bookings", "CRM"'
+          },
+          compact: {
+            type: "boolean",
+            description: "Compact output - models with relations only, no field details. Smallest output."
+          },
+          full: {
+            type: "boolean",
+            description: "Full verbose output - all fields with all attributes. Use only when you need complete details."
           }
         }
       },
@@ -39165,8 +39209,8 @@ function formatAI2(data) {
     `  <stats routers="${data.routers.length}" procedures="${data.totalProcedures}" queries="${data.queries}" mutations="${data.mutations}" protected="${data.protectedCount}" />`
   );
   lines.push("");
-  const grouped = groupByDomain2(data.routers);
-  for (const [domain, routers] of Object.entries(grouped)) {
+  const grouped = groupByDomainDynamic(data.routers);
+  for (const [domain, routers] of grouped) {
     if (routers.length === 0) continue;
     lines.push(`  <domain name="${domain}">`);
     for (const router of routers) {
@@ -39186,6 +39230,80 @@ function formatAI2(data) {
   lines.push("</trpc-routes>");
   return lines.join("\n");
 }
+function formatSmart(data) {
+  const lines = [];
+  const protectedRatio = data.protectedCount / data.totalProcedures;
+  const mostProtected = protectedRatio > 0.6;
+  lines.push("<trpc-routes>");
+  lines.push(
+    `  <stats routers="${data.routers.length}" procedures="${data.totalProcedures}" queries="${data.queries}" mutations="${data.mutations}" />`
+  );
+  if (mostProtected) {
+    lines.push(
+      `  <note>Most procedures are protected (${Math.round(protectedRatio * 100)}%). Unprotected shown explicitly.</note>`
+    );
+  }
+  const grouped = groupByDomainDynamic(data.routers);
+  const domains = Array.from(grouped.keys());
+  lines.push(`  <domains>${domains.join(", ")}</domains>`);
+  lines.push("");
+  for (const [domain, routers] of grouped) {
+    if (routers.length === 0) continue;
+    lines.push(`  <domain name="${domain}">`);
+    for (const router of routers) {
+      const queries = router.procedures.filter((p) => p.type === "query").map((p) => p.name);
+      const mutations = router.procedures.filter((p) => p.type === "mutation").map((p) => p.name);
+      const unprotected = router.procedures.filter((p) => !p.isProtected).map((p) => p.name);
+      lines.push(`    <router file="${router.file}">`);
+      if (queries.length > 0) {
+        lines.push(`      <queries>${queries.join(", ")}</queries>`);
+      }
+      if (mutations.length > 0) {
+        lines.push(`      <mutations>${mutations.join(", ")}</mutations>`);
+      }
+      if (mostProtected && unprotected.length > 0) {
+        lines.push(`      <public>${unprotected.join(", ")}</public>`);
+      }
+      if (!mostProtected) {
+        const protectedProcs = router.procedures.filter((p) => p.isProtected).map((p) => p.name);
+        if (protectedProcs.length > 0) {
+          lines.push(`      <protected>${protectedProcs.join(", ")}</protected>`);
+        }
+      }
+      lines.push("    </router>");
+    }
+    lines.push("  </domain>");
+    lines.push("");
+  }
+  lines.push("</trpc-routes>");
+  return lines.join("\n");
+}
+function formatCompact(data) {
+  const lines = [];
+  lines.push('<trpc-routes mode="compact">');
+  lines.push(
+    `  <stats routers="${data.routers.length}" procedures="${data.totalProcedures}" queries="${data.queries}" mutations="${data.mutations}" />`
+  );
+  const grouped = groupByDomainDynamic(data.routers);
+  const domains = Array.from(grouped.keys());
+  lines.push(`  <domains>${domains.join(", ")}</domains>`);
+  lines.push("");
+  for (const [domain, routers] of grouped) {
+    if (routers.length === 0) continue;
+    const routerSummaries = routers.map((r) => {
+      const q = r.procedures.filter((p) => p.type === "query").length;
+      const m = r.procedures.filter((p) => p.type === "mutation").length;
+      return `${r.file}(${q}Q/${m}M)`;
+    });
+    lines.push(`  <domain name="${domain}">`);
+    lines.push(`    ${routerSummaries.join(", ")}`);
+    lines.push("  </domain>");
+  }
+  lines.push("");
+  lines.push("  <hint>Use --full for procedure details</hint>");
+  lines.push("</trpc-routes>");
+  return lines.join("\n");
+}
 function formatMarkdown2(data) {
   const lines = [
     "# API Routes (tRPC)",
@@ -39224,28 +39342,34 @@ function formatMarkdown2(data) {
   lines.push("*Generated by krolik-cli*");
   return lines.join("\n");
 }
-function groupByDomain2(routers) {
-  const domains = {
-    Business: [],
-    User: [],
-    Content: [],
-    Social: [],
-    System: []
-  };
+function groupByDomainDynamic(routers) {
+  const result = /* @__PURE__ */ new Map();
   for (const router of routers) {
-    if (router.file.startsWith("business")) {
-      domains.Business?.push(router);
-    } else if (["user", "favorites", "userLists", "userTodos"].some((k) => router.file.includes(k))) {
-      domains.User?.push(router);
-    } else if (["places", "events", "reviews", "search"].some((k) => router.file.includes(k))) {
-      domains.Content?.push(router);
-    } else if (["social", "activity", "referral", "interactions"].some((k) => router.file.includes(k))) {
-      domains.Social?.push(router);
-    } else {
-      domains.System?.push(router);
+    const domain = inferDomainFromPath(router.file);
+    if (!result.has(domain)) {
+      result.set(domain, []);
     }
+    result.get(domain).push(router);
   }
-  return domains;
+  return new Map([...result.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+function inferDomainFromPath(filePath) {
+  const firstSegment = filePath.split("/")[0] ?? filePath;
+  if (firstSegment.startsWith("business")) {
+    return "Business";
+  }
+  if (firstSegment.startsWith("admin")) {
+    return "Admin";
+  }
+  return firstSegment.charAt(0).toUpperCase() + firstSegment.slice(1);
+}
+function groupByDomain2(routers) {
+  const grouped = groupByDomainDynamic(routers);
+  const result = {};
+  for (const [domain, routerList] of grouped) {
+    result[domain] = routerList;
+  }
+  return result;
 }
 var MAX_LENGTH2, SLICE_ARG1_VALUE2;
 var init_output6 = __esm({
@@ -39583,7 +39707,15 @@ async function runRoutes(ctx) {
     printRoutes(result, logger2);
     return;
   }
-  console.log(xmlOutput);
+  if (options.compact) {
+    console.log(formatCompact(result));
+    return;
+  }
+  if (options.full) {
+    console.log(xmlOutput);
+    return;
+  }
+  console.log(formatSmart(result));
 }
 var init_routes3 = __esm({
   "src/commands/routes/index.ts"() {
@@ -39594,42 +39726,246 @@ var init_routes3 = __esm({
   }
 });
 
+// src/commands/schema/relation-graph.ts
+function buildRelationGraph(models) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    nodes.set(model.name, {
+      model: model.name,
+      file: model.file,
+      relations: model.relations,
+      referencedBy: [],
+      inDegree: 0,
+      outDegree: model.relations.length
+    });
+  }
+  for (const model of models) {
+    for (const relation of model.relations) {
+      const targetNode = nodes.get(relation);
+      if (targetNode) {
+        targetNode.referencedBy.push(model.name);
+        targetNode.inDegree++;
+      }
+    }
+  }
+  return nodes;
+}
+function findSCC(nodes) {
+  const state = {
+    index: /* @__PURE__ */ new Map(),
+    lowlink: /* @__PURE__ */ new Map(),
+    onStack: /* @__PURE__ */ new Set(),
+    stack: [],
+    sccs: [],
+    currentIndex: 0
+  };
+  function strongConnect(nodeId) {
+    state.index.set(nodeId, state.currentIndex);
+    state.lowlink.set(nodeId, state.currentIndex);
+    state.currentIndex++;
+    state.stack.push(nodeId);
+    state.onStack.add(nodeId);
+    const node = nodes.get(nodeId);
+    const deps = node?.relations ?? [];
+    for (const depId of deps) {
+      if (!nodes.has(depId)) continue;
+      if (!state.index.has(depId)) {
+        strongConnect(depId);
+        state.lowlink.set(nodeId, Math.min(state.lowlink.get(nodeId), state.lowlink.get(depId)));
+      } else if (state.onStack.has(depId)) {
+        state.lowlink.set(nodeId, Math.min(state.lowlink.get(nodeId), state.index.get(depId)));
+      }
+    }
+    if (state.lowlink.get(nodeId) === state.index.get(nodeId)) {
+      const scc = [];
+      let w;
+      do {
+        w = state.stack.pop();
+        state.onStack.delete(w);
+        scc.push(w);
+      } while (w !== nodeId);
+      state.sccs.push(scc);
+    }
+  }
+  for (const nodeId of nodes.keys()) {
+    if (!state.index.has(nodeId)) {
+      strongConnect(nodeId);
+    }
+  }
+  return state.sccs;
+}
+function findCommonPrefix(models) {
+  if (models.length < 2) return null;
+  const prefixes = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const parts = model.split(/(?=[A-Z])/);
+    if (parts.length >= 2) {
+      const prefix = parts[0];
+      if (prefix.length >= 3) {
+        prefixes.set(prefix, (prefixes.get(prefix) ?? 0) + 1);
+      }
+    }
+  }
+  for (const [prefix, count] of prefixes) {
+    const ratio = count / models.length;
+    if (ratio >= 0.6) {
+      return prefix;
+    }
+  }
+  return null;
+}
+function findCoreEntity(models, nodes) {
+  let maxInDegree = 0;
+  let core = null;
+  for (const model of models) {
+    const node = nodes.get(model);
+    if (node && node.inDegree > maxInDegree) {
+      maxInDegree = node.inDegree;
+      core = model;
+    }
+  }
+  return maxInDegree >= 2 ? core : null;
+}
+function inferClusterName(models, nodes) {
+  const prefix = findCommonPrefix(models);
+  if (prefix) {
+    return {
+      name: prefix.endsWith("s") ? prefix : `${prefix}s`,
+      confidence: 85,
+      source: "prefix"
+    };
+  }
+  const core = findCoreEntity(models, nodes);
+  if (core && models.length >= 2) {
+    return {
+      name: core.endsWith("s") ? core : `${core}s`,
+      confidence: 75,
+      source: "core-entity"
+    };
+  }
+  const files = new Set(models.map((m) => nodes.get(m)?.file ?? ""));
+  if (files.size === 1) {
+    const file = [...files][0];
+    const domain = file.replace(/\.prisma$/, "").replace(/^.*\//, "");
+    if (domain && domain !== "schema") {
+      return {
+        name: domain.charAt(0).toUpperCase() + domain.slice(1),
+        confidence: 50,
+        source: "filename"
+      };
+    }
+  }
+  return { name: "", confidence: 0, source: "filename" };
+}
+function analyzeRelationGraph(models) {
+  const nodes = buildRelationGraph(models);
+  const sccs = findSCC(nodes);
+  const clusters = [];
+  const unclustered = [];
+  for (const scc of sccs) {
+    if (scc.length < MIN_CLUSTER_SIZE) {
+      const node = nodes.get(scc[0]);
+      if (!node || node.inDegree < 3 && node.outDegree < 3) {
+        unclustered.push(...scc);
+        continue;
+      }
+    }
+    const { name, confidence, source } = inferClusterName(scc, nodes);
+    if (confidence < MIN_CONFIDENCE2) {
+      unclustered.push(...scc);
+      continue;
+    }
+    const core = findCoreEntity(scc, nodes);
+    clusters.push({
+      name,
+      core,
+      models: scc.sort(),
+      confidence,
+      source
+    });
+  }
+  clusters.sort((a, b) => b.models.length - a.models.length);
+  return {
+    nodes: Array.from(nodes.values()),
+    clusters,
+    unclustered: unclustered.sort()
+  };
+}
+var MIN_CONFIDENCE2, MIN_CLUSTER_SIZE;
+var init_relation_graph = __esm({
+  "src/commands/schema/relation-graph.ts"() {
+    init_esm_shims();
+    MIN_CONFIDENCE2 = 60;
+    MIN_CLUSTER_SIZE = 2;
+  }
+});
+
 // src/commands/schema/grouping.ts
 function groupByFile2(models) {
   return groupByProperty(models, "file");
 }
 function groupByDomain3(models) {
-  return groupBy(models, (model) => inferDomain(model.file));
-}
-function inferDomain(filename) {
-  const base = filename.replace(".prisma", "").toLowerCase();
-  for (const [key, label] of Object.entries(DEFAULT_DOMAINS)) {
-    if (base.includes(key)) {
-      return label;
+  if (models.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const files = new Set(models.map((m) => m.file));
+  const isSingleFile = files.size === 1;
+  if (!isSingleFile) {
+    return groupByFilename(models);
+  }
+  const { clusters, unclustered } = analyzeRelationGraph(models);
+  if (clusters.length === 0) {
+    return groupByFilename(models);
+  }
+  const result = /* @__PURE__ */ new Map();
+  const modelMap = new Map(models.map((m) => [m.name, m]));
+  for (const cluster of clusters) {
+    const clusterModels = cluster.models.map((name) => modelMap.get(name)).filter((m) => m !== void 0);
+    if (clusterModels.length > 0) {
+      result.set(cluster.name, clusterModels);
+    }
+  }
+  if (unclustered.length > 0) {
+    const unclusteredModels = unclustered.map((name) => modelMap.get(name)).filter((m) => m !== void 0);
+    for (const model of unclusteredModels) {
+      const domain = inferDomainFromFilename(model.file);
+      const existing = result.get(domain) ?? [];
+      existing.push(model);
+      result.set(domain, existing);
     }
   }
-  return "Other";
+  return new Map([...result.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+function groupByFilename(models) {
+  const result = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const domain = inferDomainFromFilename(model.file);
+    const existing = result.get(domain) ?? [];
+    existing.push(model);
+    result.set(domain, existing);
+  }
+  return new Map([...result.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+function inferDomainFromFilename(filename) {
+  const base = filename.replace(/\.prisma$/, "").replace(/^.*\//, "");
+  if (!base || base === "schema") return "Other";
+  const parts = base.split(/[-_]/);
+  const formatted = parts.map((part) => {
+    const lower = part.toLowerCase();
+    if (UPPERCASE_ABBREVS.includes(lower)) {
+      return lower.toUpperCase();
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+  });
+  return formatted.join(" ");
 }
-var DEFAULT_DOMAINS;
+var UPPERCASE_ABBREVS;
 var init_grouping4 = __esm({
   "src/commands/schema/grouping.ts"() {
     init_esm_shims();
     init_core2();
-    DEFAULT_DOMAINS = {
-      auth: "Authentication",
-      user: "Users",
-      content: "Content",
-      booking: "Bookings",
-      event: "Events",
-      ticket: "Ticketing",
-      business: "Business",
-      social: "Social",
-      gamification: "Gamification",
-      payment: "Payments",
-      notification: "Notifications",
-      integration: "Integrations",
-      system: "System"
-    };
+    init_relation_graph();
+    UPPERCASE_ABBREVS = ["crm", "api", "ugc", "sso", "oauth", "jwt", "sql"];
   }
 });
 
@@ -39756,11 +40092,208 @@ function formatMarkdown3(data) {
   lines.push("*Generated by krolik-cli*");
   return lines.join("\n");
 }
+function isObviousDefault(value) {
+  if (!value) return false;
+  return OBVIOUS_DEFAULTS.has(value) || value.startsWith('"') || value.startsWith("'");
+}
+function isRelationArray(field) {
+  return field.isArray && field.type.charAt(0) === field.type.charAt(0).toUpperCase() && ![
+    "String",
+    "Int",
+    "Float",
+    "Boolean",
+    "DateTime",
+    "Json",
+    "Bytes",
+    "BigInt",
+    "Decimal"
+  ].includes(field.type);
+}
+function classifyField(field) {
+  if (STANDARD_FIELDS.has(field.name)) return "skip";
+  if (isRelationArray(field)) return "skip";
+  if (field.name.endsWith("Id") || field.isUnique || field.isId) return "key";
+  if (field.name.includes("At") || field.name.includes("Date") || field.name.startsWith("created") || field.name.startsWith("updated")) {
+    return "meta";
+  }
+  return "business";
+}
+function formatSmart2(data, fullData) {
+  const lines = [];
+  const total = fullData ?? data;
+  const isFiltered = fullData && data.modelCount !== fullData.modelCount;
+  lines.push("<prisma-schema>");
+  if (isFiltered) {
+    lines.push(
+      `  <stats models="${data.modelCount}" enums="${data.enumCount}" filtered="true" total="${total.modelCount}" />`
+    );
+  } else {
+    lines.push(`  <stats models="${data.modelCount}" enums="${data.enumCount}" />`);
+  }
+  const byDomain = groupByDomain3(data.models);
+  const domains = Array.from(byDomain.keys()).sort();
+  lines.push(`  <domains>${domains.join(", ")}</domains>`);
+  lines.push("");
+  for (const [domain, models] of byDomain) {
+    lines.push(`  <domain name="${domain}">`);
+    for (const model of models) {
+      const keyFields = [];
+      const businessFields = [];
+      const metaFields = [];
+      const relationArrays = [];
+      for (const field of model.fields) {
+        if (isRelationArray(field)) {
+          relationArrays.push(`${field.name}\u2192${field.type}[]`);
+          continue;
+        }
+        const category = classifyField(field);
+        if (category === "skip") continue;
+        const formatted = formatFieldSmart(field);
+        switch (category) {
+          case "key":
+            keyFields.push(formatted);
+            break;
+          case "business":
+            businessFields.push(formatted);
+            break;
+          case "meta":
+            metaFields.push(formatted);
+            break;
+        }
+      }
+      lines.push(`    <model name="${model.name}">`);
+      const allRelations = [
+        ...model.relations,
+        ...relationArrays.length > 0 ? relationArrays : []
+      ];
+      if (allRelations.length > 0) {
+        lines.push(`      <relations>${allRelations.join(", ")}</relations>`);
+      }
+      if (keyFields.length > 0) {
+        lines.push(`      <keys>${keyFields.join(", ")}</keys>`);
+      }
+      if (businessFields.length > 0) {
+        lines.push(`      <data>${businessFields.join(", ")}</data>`);
+      }
+      if (metaFields.length > 0) {
+        lines.push(`      <meta>${metaFields.join(", ")}</meta>`);
+      }
+      lines.push("    </model>");
+    }
+    lines.push("  </domain>");
+    lines.push("");
+  }
+  if (data.enums.length > 0) {
+    lines.push("  <enums>");
+    const enumsByPrefix = groupEnumsByPrefix(data.enums);
+    for (const [prefix, names] of enumsByPrefix) {
+      if (names.length === 1) {
+        lines.push(`    ${names[0]}`);
+      } else {
+        lines.push(`    ${prefix}*: ${names.join(", ")}`);
+      }
+    }
+    lines.push("  </enums>");
+  }
+  lines.push("</prisma-schema>");
+  return lines.join("\n");
+}
+function formatFieldSmart(field) {
+  let result = field.name;
+  const simpleTypes = ["String", "Int", "Float", "Boolean", "DateTime", "Json"];
+  if (!simpleTypes.includes(field.type)) {
+    result += `:${field.type}`;
+  }
+  if (!field.isRequired) result += "?";
+  if (field.isUnique && !field.name.endsWith("Id")) result += "!";
+  if (field.isArray) result += "[]";
+  if (field.default && !isObviousDefault(field.default)) {
+    result += `=${field.default}`;
+  }
+  return result;
+}
+function groupEnumsByPrefix(enums) {
+  const result = /* @__PURE__ */ new Map();
+  for (const e of enums) {
+    const match = e.name.match(/^([A-Z][a-z]+)/);
+    const prefix = match?.[1] ?? "Other";
+    if (!result.has(prefix)) result.set(prefix, []);
+    result.get(prefix).push(e.name);
+  }
+  return new Map([...result.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+function formatCompact2(data, fullData) {
+  const lines = [];
+  const total = fullData ?? data;
+  const isFiltered = fullData && data.modelCount !== fullData.modelCount;
+  lines.push('<prisma-schema mode="compact">');
+  if (isFiltered) {
+    lines.push(
+      `  <stats models="${data.modelCount}" enums="${data.enumCount}" filtered="true" total-models="${total.modelCount}" total-enums="${total.enumCount}" />`
+    );
+  } else {
+    lines.push(`  <stats models="${data.modelCount}" enums="${data.enumCount}" />`);
+  }
+  const byDomain = groupByDomain3(data.models);
+  const domains = Array.from(byDomain.keys()).sort();
+  lines.push(`  <domains>${domains.join(", ")}</domains>`);
+  lines.push("");
+  for (const [domain, models] of byDomain) {
+    const modelCount = models.length;
+    lines.push(`  <domain name="${domain}" models="${modelCount}">`);
+    for (const model of models) {
+      const relStr = model.relations.length > 0 ? ` relations="${model.relations.join(", ")}"` : "";
+      const keyFields = model.fields.filter((f) => f.isId || f.isUnique || f.name.endsWith("Id"));
+      const keyFieldNames = keyFields.map((f) => f.name).slice(0, 5);
+      const keyStr = keyFieldNames.length > 0 ? ` keys="${keyFieldNames.join(", ")}"` : "";
+      lines.push(
+        `    <model name="${model.name}" fields="${model.fields.length}"${relStr}${keyStr} />`
+      );
+    }
+    lines.push("  </domain>");
+  }
+  if (data.enums.length > 0) {
+    lines.push("");
+    lines.push(`  <enums count="${data.enums.length}">`);
+    const enumNames = data.enums.map((e) => e.name).sort();
+    if (enumNames.length > 20) {
+      const byPrefix = /* @__PURE__ */ new Map();
+      for (const name of enumNames) {
+        const prefix = name.replace(/[A-Z][a-z]+$/, "").replace(/Status$|Type$|Role$|State$/, "") || "General";
+        if (!byPrefix.has(prefix)) byPrefix.set(prefix, []);
+        byPrefix.get(prefix).push(name);
+      }
+      for (const [prefix, names] of byPrefix) {
+        lines.push(`    <group prefix="${prefix}">${names.join(", ")}</group>`);
+      }
+    } else {
+      lines.push(`    ${enumNames.join(", ")}`);
+    }
+    lines.push("  </enums>");
+  }
+  lines.push("");
+  lines.push('  <hint>Use --model "Name" or --domain "Domain" for details</hint>');
+  lines.push("</prisma-schema>");
+  return lines.join("\n");
+}
+var STANDARD_FIELDS, OBVIOUS_DEFAULTS;
 var init_output7 = __esm({
   "src/commands/schema/output.ts"() {
     init_esm_shims();
     init_format();
     init_grouping4();
+    STANDARD_FIELDS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+    OBVIOUS_DEFAULTS = /* @__PURE__ */ new Set([
+      "cuid(",
+      "uuid(",
+      "now(",
+      "autoincrement(",
+      "false",
+      "true",
+      "0",
+      "1",
+      '""'
+    ]);
   }
 });
 
@@ -39800,6 +40333,29 @@ function findSchemaDir2(projectRoot, configSchemaDir) {
   }
   return null;
 }
+function filterSchema(result, options) {
+  let { models, enums } = result;
+  if (options.domain) {
+    const domainLower = options.domain.toLowerCase();
+    const byDomain = groupByDomain3(models);
+    const matchingDomain = Array.from(byDomain.keys()).find((d) => d.toLowerCase() === domainLower);
+    if (matchingDomain) {
+      models = byDomain.get(matchingDomain) ?? [];
+    } else {
+      models = [];
+    }
+  }
+  if (options.model) {
+    const modelLower = options.model.toLowerCase();
+    models = models.filter((m) => m.name.toLowerCase().includes(modelLower));
+  }
+  return {
+    models,
+    enums,
+    modelCount: models.length,
+    enumCount: enums.length
+  };
+}
 async function runSchema(ctx) {
   const { config, logger: logger2, options } = ctx;
   const schemaDir = findSchemaDir2(config.projectRoot, config.prisma?.schemaDir);
@@ -39808,9 +40364,11 @@ async function runSchema(ctx) {
     logger2.info("Checked: prisma, packages/db/prisma, src/prisma, db/prisma");
     return;
   }
-  const result = analyzeSchema(schemaDir);
+  const fullResult = analyzeSchema(schemaDir);
+  const hasFilters = options.model || options.domain;
+  const result = hasFilters ? filterSchema(fullResult, options) : fullResult;
   const format2 = options.format ?? "ai";
-  const xmlOutput = formatAI3(result);
+  const xmlOutput = formatAI3(fullResult);
   saveKrolikFile(config.projectRoot, "SCHEMA.xml", xmlOutput);
   if (options.save) {
     const md = formatMarkdown3(result);
@@ -39831,12 +40389,21 @@ async function runSchema(ctx) {
     printSchema(result, logger2, options.groupBy ?? "file");
     return;
   }
-  console.log(xmlOutput);
+  if (options.compact) {
+    console.log(formatCompact2(result, fullResult));
+    return;
+  }
+  if (options.full) {
+    console.log(hasFilters ? formatAI3(result) : xmlOutput);
+    return;
+  }
+  console.log(formatSmart2(result, hasFilters ? fullResult : void 0));
 }
 var init_schema3 = __esm({
   "src/commands/schema/index.ts"() {
     init_esm_shims();
     init_fs2();
+    init_grouping4();
     init_output7();
     init_parser2();
   }
@@ -59071,21 +59638,85 @@ function registerReviewCommand(program) {
 
 // src/cli/commands/routes.ts
 init_esm_shims();
+init_projects();
 function registerRoutesCommand(program) {
-  program.command("routes").description("Analyze tRPC routes").option("--save", "Save to ROUTES.md").action(async (options) => {
+  program.command("routes").description("Analyze tRPC routes").option("--save", "Save to ROUTES.md").option("-c, --compact", "Compact output (routers with procedure counts only)").option("-f, --full", "Full verbose output (all procedures with all attributes)").option("-p, --project <name>", "Project folder name (for multi-project workspaces)").addHelpText(
+    "after",
+    `
+Output modes:
+  (default)   Smart format - groups procedures by type, shows only exceptions
+  --compact   Overview only - routers with Q/M counts
+  --full      Verbose - all procedures, all attributes (legacy format)
+
+Examples:
+  krolik routes                           # Smart format (recommended)
+  krolik routes --compact                 # Compact overview
+  krolik routes --full                    # Full verbose output
+  krolik routes --project piternow-wt-fix # Specific project
+`
+  ).action(async (options) => {
     const { runRoutes: runRoutes2 } = await Promise.resolve().then(() => (init_routes3(), routes_exports));
+    if (options.project) {
+      const resolved = resolveProjectPath(process.cwd(), options.project);
+      if ("error" in resolved) {
+        console.error(resolved.error);
+        process.exit(1);
+      }
+      process.env.KROLIK_PROJECT_ROOT = resolved.path;
+    }
     const ctx = await createContext3(program, options);
-    await runRoutes2(ctx);
+    await runRoutes2({
+      ...ctx,
+      options: {
+        ...ctx.options,
+        compact: options.compact,
+        full: options.full
+      }
+    });
   });
 }
 
 // src/cli/commands/schema.ts
 init_esm_shims();
+init_projects();
 function registerSchemaCommand(program) {
-  program.command("schema").description("Analyze Prisma schema").option("--save", "Save to SCHEMA.md").action(async (options) => {
+  program.command("schema").description("Analyze Prisma schema").option("--save", "Save to SCHEMA.md").option("-m, --model <name>", "Filter by model name (partial match)").option("-d, --domain <name>", "Filter by domain name").option("-c, --compact", "Compact output (models with relations only, no field details)").option("-f, --full", "Full verbose output (all fields with all attributes)").option("-p, --project <name>", "Project folder name (for multi-project workspaces)").addHelpText(
+    "after",
+    `
+Output modes:
+  (default)   Smart format - optimized for AI, hides standard fields
+  --compact   Overview only - models with relations, no field details
+  --full      Verbose - all fields, all attributes (legacy format)
+
+Examples:
+  krolik schema                           # Smart format (recommended)
+  krolik schema --compact                 # Compact overview
+  krolik schema --full                    # Full verbose output
+  krolik schema --domain Bookings         # Only Bookings domain
+  krolik schema --model User              # Only models containing "User"
+  krolik schema --project piternow-wt-fix # Specific project
+`
+  ).action(async (options) => {
     const { runSchema: runSchema2 } = await Promise.resolve().then(() => (init_schema3(), schema_exports));
+    if (options.project) {
+      const resolved = resolveProjectPath(process.cwd(), options.project);
+      if ("error" in resolved) {
+        console.error(resolved.error);
+        process.exit(1);
+      }
+      process.env.KROLIK_PROJECT_ROOT = resolved.path;
+    }
     const ctx = await createContext3(program, options);
-    await runSchema2(ctx);
+    await runSchema2({
+      ...ctx,
+      options: {
+        ...ctx.options,
+        model: options.model,
+        domain: options.domain,
+        compact: options.compact,
+        full: options.full
+      }
+    });
   });
 }