@01.software/cli 0.10.0 → 0.10.1

package/dist/index.js

@@ -1552,6 +1552,214 @@ function registerSchemaCommands(program2, getClient2, getFormat2) {
   });
 }
 
+// ../contracts/src/tenant/index.ts
+import { z as z3 } from "zod";
+var tenantFieldConfigStateSchema = z3.object({
+  hiddenFields: z3.array(z3.string()),
+  isHidden: z3.boolean()
+}).strict();
+var tenantContextQuerySchema = z3.object({
+  counts: z3.literal("true").optional()
+}).strict();
+var tenantContextToolInputSchema = z3.object({
+  includeCounts: z3.boolean().optional().default(false).describe(
+    "Include per-collection document counts and config status (bypasses cache, slower)"
+  )
+}).strict();
+var tenantContextResponseSchema = z3.object({
+  tenant: z3.object({
+    id: z3.string(),
+    name: z3.string(),
+    plan: z3.string(),
+    planSource: z3.string().optional(),
+    authoritative: z3.boolean().optional(),
+    capabilityVersion: z3.string().optional()
+  }).strict(),
+  features: z3.array(z3.string()),
+  collections: z3.object({
+    active: z3.array(z3.string()),
+    inactive: z3.array(z3.string())
+  }).strict(),
+  fieldConfigs: z3.record(z3.string(), tenantFieldConfigStateSchema),
+  counts: z3.record(z3.string(), z3.number()).optional(),
+  config: z3.object({
+    webhookConfigured: z3.boolean()
+  }).strict().optional()
+}).strict();
+var tenantFeatureProgressFeatureSchema = z3.enum(["ecommerce"]);
+var tenantFeatureProgressInputSchema = z3.object({
+  feature: tenantFeatureProgressFeatureSchema.describe(
+    "Feature to inspect for tenant implementation readiness"
+  ),
+  includeEvidence: z3.boolean().optional().default(false).describe("Include sanitized counts and static surface evidence")
+}).strict();
+var tenantFeatureProgressStatusSchema = z3.enum([
+  "ready",
+  "attention",
+  "blocked"
+]);
+var tenantFeatureProgressItemStateSchema = z3.enum([
+  "complete",
+  "incomplete",
+  "blocked",
+  "attention",
+  "optional",
+  "unknown",
+  "manual",
+  "not-applicable"
+]);
+var tenantFeatureProgressSeveritySchema = z3.enum([
+  "required",
+  "recommended",
+  "optional"
+]);
+var tenantFeatureProgressEvidenceValueSchema = z3.union([
+  z3.string(),
+  z3.number(),
+  z3.boolean(),
+  z3.null()
+]);
+var tenantFeatureProgressItemSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  state: tenantFeatureProgressItemStateSchema,
+  severity: tenantFeatureProgressSeveritySchema,
+  summary: z3.string(),
+  evidence: z3.record(z3.string(), tenantFeatureProgressEvidenceValueSchema).optional()
+}).strict();
+var tenantFeatureProgressGroupSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  summary: z3.string().optional(),
+  items: z3.array(tenantFeatureProgressItemSchema)
+}).strict();
+var tenantFeatureProgressResponseSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  feature: tenantFeatureProgressFeatureSchema,
+  status: tenantFeatureProgressStatusSchema,
+  generatedAt: z3.string(),
+  tenant: z3.object({
+    id: z3.string(),
+    name: z3.string(),
+    plan: z3.string()
+  }).strict(),
+  capability: z3.object({
+    effectiveFeatures: z3.array(z3.string()),
+    planBlocked: z3.array(z3.string()),
+    closureAdded: z3.array(z3.string())
+  }).strict(),
+  summary: z3.object({
+    complete: z3.number().int().nonnegative(),
+    total: z3.number().int().nonnegative(),
+    blocking: z3.number().int().nonnegative(),
+    manual: z3.number().int().nonnegative(),
+    unknown: z3.number().int().nonnegative()
+  }).strict(),
+  groups: z3.array(tenantFeatureProgressGroupSchema)
+}).strict();
+var COLLECTION_SCHEMA_CONTRACT_VERSION = 1;
+var collectionSchemaEndpointParamsSchema = z3.object({
+  collectionSlug: z3.string().min(1, "collectionSlug is required")
+}).strict();
+var collectionFieldOptionSchema = z3.object({
+  label: z3.string(),
+  value: z3.string()
+}).strict();
+var collectionFieldSchema = z3.lazy(
+  () => z3.object({
+    name: z3.string(),
+    path: z3.string(),
+    type: z3.string(),
+    required: z3.literal(true).optional(),
+    unique: z3.literal(true).optional(),
+    hasMany: z3.literal(true).optional(),
+    relationTo: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+    options: z3.array(collectionFieldOptionSchema).optional(),
+    hidden: z3.literal(true).optional(),
+    systemManaged: z3.literal(true).optional(),
+    writable: z3.boolean().optional(),
+    fields: z3.array(collectionFieldSchema).optional()
+  }).strict()
+);
+var collectionSchemaResponseSchema = z3.object({
+  contractVersion: z3.literal(COLLECTION_SCHEMA_CONTRACT_VERSION),
+  mode: z3.literal("effective"),
+  collection: z3.object({
+    slug: z3.string(),
+    timestamps: z3.boolean(),
+    alwaysActive: z3.boolean(),
+    feature: z3.string().nullable(),
+    systemFields: z3.array(z3.string()),
+    visibility: z3.object({
+      collectionHidden: z3.boolean(),
+      hiddenFields: z3.array(z3.string())
+    }).strict(),
+    fields: z3.array(collectionFieldSchema)
+  }).strict()
+}).strict();
+
+// src/commands/feature.ts
+function getApiUrl2() {
+  return (process.env.SOFTWARE_API_URL || process.env.NEXT_PUBLIC_SOFTWARE_API_URL || "https://api.01.software").replace(/\/$/, "");
+}
+function flattenProgress(progress) {
+  return progress.groups.flatMap(
+    (group) => group.items.map((item) => ({
+      group: group.title,
+      item: item.title,
+      state: item.state,
+      severity: item.severity,
+      summary: item.summary
+    }))
+  );
+}
+function registerFeatureCommands(program2, getClient2, getFormat2) {
+  const feature = program2.command("feature").description("Feature implementation progress checks");
+  feature.command("check <feature>").description("Check tenant implementation progress for a feature").option("--evidence", "Include sanitized evidence counts and surface flags").action(async (featureName, options) => {
+    try {
+      const input = parseWithSchema(
+        {
+          feature: featureName,
+          includeEvidence: Boolean(options.evidence)
+        },
+        "feature",
+        tenantFeatureProgressInputSchema
+      );
+      const client = getClient2();
+      const baseUrl = getApiUrl2();
+      const search = new URLSearchParams({ feature: input.feature });
+      if (input.includeEvidence) search.set("includeEvidence", "true");
+      const response = await fetch(
+        `${baseUrl}/api/tenants/feature-progress?${search.toString()}`,
+        {
+          headers: {
+            "X-Publishable-Key": client.publishableKey,
+            Authorization: `Bearer ${client.secretKey}`
+          }
+        }
+      );
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({ error: response.statusText }));
+        const err = new Error(
+          body.error || `HTTP ${response.status}`
+        );
+        Object.assign(err, { status: response.status });
+        throw err;
+      }
+      const result = tenantFeatureProgressResponseSchema.parse(
+        await response.json()
+      );
+      const format = getFormat2();
+      printResult(
+        format === "table" ? flattenProgress(result) : result,
+        format
+      );
+    } catch (error) {
+      exitWithError(error);
+    }
+  });
+}
+
 // src/commands/mcp.ts
 import { resolve, dirname } from "path";
 import { existsSync as existsSync2 } from "fs";
@@ -1664,6 +1872,7 @@ registerCartCommands(program, getClient, getFormat);
 registerStockCommands(program, getClient, getFormat);
 registerTransactionCommands(program, getClient, getFormat);
 registerSchemaCommands(program, getClient, getFormat);
+registerFeatureCommands(program, getClient, getFormat);
 registerMcpCommands(program);
 registerAuthCommands(program);
 program.parse();