@dench.com/cli 0.4.7 → 0.4.9

package/crm.ts

@@ -48,11 +48,21 @@ import {
   type FieldCandidate,
 } from "./lib/crm-enrichment";
 import {
+  aviatoEnrichCompany,
+  aviatoEnrichPerson,
   enrichCompany,
   EnrichmentGatewayError,
   enrichPersonByIdentifier,
 } from "./lib/enrichment-gateway";
 
+// Contact-info fields that Aviato does not return.
+const CONTACT_REQUIRED_FIELDS = ["phone", "email", "personal_email"] as const;
+type ContactRequiredField = (typeof CONTACT_REQUIRED_FIELDS)[number];
+
+function isContactField(field: string): field is ContactRequiredField {
+  return (CONTACT_REQUIRED_FIELDS as readonly string[]).includes(field);
+}
+
 type JsonRecord = Record<string, unknown>;
 
 const CRM_BATCH_CHUNK_SIZE = 200;
@@ -412,6 +422,9 @@ const api = {
       "functions/crm/actions:startActionRun",
     ),
   },
+  members: {
+    list: makeFunctionReference<"query">("functions/crm/members:list"),
+  },
 };
 
 export async function runCrmCommand(opts: {
@@ -472,11 +485,31 @@ export async function runCrmCommand(opts: {
       return await runDocsCommand(ctx);
     case "actions":
       return await runActionsCommand(ctx);
+    case "members":
+      // Alias for `dench members` so the AI agent finds the roster
+      // surface from inside the `dench crm` namespace it's primed
+      // on. Delegates to the shared implementation in cli/members.ts
+      // so payload formatting + flag handling stay in lockstep.
+      return await runCrmMembersCommand(ctx);
     default:
       throw new CrmCliError(`Unknown crm subcommand: ${subcommand}`);
   }
 }
 
+async function runCrmMembersCommand(ctx: CrmCliContext): Promise<void> {
+  const { runMembersCommand } = await import("./members");
+  // Re-prepend `--json` so the members dispatcher's own `hasFlag`
+  // pass sees it again — we already drained it once when computing
+  // `ctx.jsonOutput`, but the members CLI re-parses argv from scratch
+  // (same shape as a top-level invocation).
+  const args = ctx.jsonOutput ? ["--json", ...ctx.args] : [...ctx.args];
+  await runMembersCommand({
+    convex: ctx.convex,
+    args,
+    sessionToken: ctx.sessionToken,
+  });
+}
+
 async function runObjectsCommand(ctx: CrmCliContext): Promise<void> {
   const verb = ctx.args.shift();
   switch (verb) {
@@ -665,8 +698,32 @@ async function runEntriesCommand(ctx: CrmCliContext): Promise<void> {
     case "list": {
       const objectName = shift(ctx.args, "object name");
       const limit = parseInt(getFlag(ctx.args, "--limit") ?? "100", 10);
+      const withMeta = hasFlag(ctx.args, "--with-meta");
       assertNoUnknownFlags(ctx.args, "crm entries list");
-      out(ctx, await callQuery(ctx, api.entries.list, { objectName, limit }));
+      const entries = await callQuery(ctx, api.entries.list, {
+        objectName,
+        limit,
+      });
+      if (!withMeta) {
+        out(ctx, entries);
+        return;
+      }
+      const object = (await callQuery(ctx, api.objects.get, {
+        name: objectName,
+      })) as { entryCount?: number } | null;
+      const returnedCount = Array.isArray(entries) ? entries.length : 0;
+      const totalCount =
+        typeof object?.entryCount === "number"
+          ? object.entryCount
+          : returnedCount;
+      out(ctx, {
+        objectName,
+        totalCount,
+        returnedCount,
+        limit,
+        hasMore: totalCount > returnedCount,
+        entries,
+      });
       return;
     }
     case "get": {
@@ -1634,6 +1691,8 @@ async function resolveEnrichmentTarget(
 async function callEnrichmentGatewayForEntry(args: {
   target: EnrichmentTarget;
   entry: CrmEntryForEnrichment;
+  /** Explicit provider override. Defaults: people=fullenrich, company=aviato. */
+  provider?: string;
 }): Promise<Record<string, unknown>> {
   const input = args.entry.fields[args.target.inputField.name];
   if (!hasCellValue(input)) {
@@ -1642,13 +1701,42 @@ async function callEnrichmentGatewayForEntry(args: {
     );
   }
   const inputValue = String(input);
-  if (args.target.category === "people") {
-    return await enrichPersonByIdentifier(inputValue, args.target.requiredFields);
+  const isCompany = args.target.category === "company";
+  const resolvedProvider = args.provider ?? (isCompany ? "aviato" : "fullenrich");
+
+  if (resolvedProvider === "aviato") {
+    // Guard: Aviato does not return phone or email.
+    const contactFields = args.target.requiredFields.filter(isContactField);
+    if (contactFields.length > 0) {
+      throw new CrmCliError(
+        `Aviato does not return phone or email; use --provider fullenrich for contact fields (${contactFields.join(", ")}).`,
+      );
+    }
+
+    if (isCompany) {
+      // inputValue is typically a domain; try to detect linkedin URLs
+      const isLinkedin = /linkedin\.com/i.test(inputValue);
+      return aviatoEnrichCompany(
+        isLinkedin ? { linkedinUrl: inputValue } : { website: inputValue },
+      );
+    } else {
+      // For people, inputValue may be a LinkedIn URL, email, or LinkedIn ID
+      const isLinkedin = /linkedin\.com/i.test(inputValue);
+      const isEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(inputValue);
+      if (isLinkedin) return aviatoEnrichPerson({ linkedinUrl: inputValue });
+      if (isEmail) return aviatoEnrichPerson({ email: inputValue });
+      return aviatoEnrichPerson({ linkedinID: inputValue });
+    }
   }
-  return await enrichCompany({
-    domain: inputValue,
-    requiredFields: args.target.requiredFields,
-  });
+
+  // fullenrich path (default for people, explicit override for companies)
+  if (isCompany) {
+    return enrichCompany({
+      domain: inputValue,
+      requiredFields: args.target.requiredFields,
+    });
+  }
+  return enrichPersonByIdentifier(inputValue, args.target.requiredFields);
 }
 
 async function enrichOneEntry(
@@ -1662,6 +1750,7 @@ async function enrichOneEntry(
     const payload = await callEnrichmentGatewayForEntry({
       target: args.target,
       entry: args.entry,
+      provider: args.provider,
     });
     const value = extractEnrichmentValue(payload, args.target.column);
     if (value === null) {
@@ -2026,7 +2115,7 @@ Fields (columns):
   dench crm fields reorder <object> <field1> <field2> <field3> ...
 
 Entries (rows):
-  dench crm entries list <object> [--limit N] [--json]
+  dench crm entries list <object> [--limit N] [--with-meta] [--json]
   dench crm entries get <object> <entryId>
   dench crm entries create <object> --data '{"Field":"Value",...}'    (alias: --fields)
   dench crm entries create-many <object> --data '[{"Field":"Value",...}]' [--file rows.json] [--idempotency-key <key>]
@@ -2057,6 +2146,15 @@ Statuses (kanban columns):
   dench crm statuses list <object>
   dench crm statuses set <object> --statuses '[{"name":"New","color":"#94a3b8"},...]'
 
+Workspace members (for user-type fields):
+  dench crm members list [--json]              (alias: dench members list)
+      List \`{ userId, role, name, email }\` for every member of the
+      current org. Use the userIds when setting \`Owner\`, \`Assignee\`,
+      or any other \`user\`-type field so the UI shows a real linked
+      avatar instead of an unlinked literal-string badge:
+        dench crm cells set task --entry <id> --field Owner --value <userId>
+        dench crm entries create task --data '{"Name":"X","Owner":"<userId>"}'
+
 Batch:
   dench crm batch --file ops.jsonl [--idempotency-key <key>]
   For repeated writes, prefer entries create-many/update-many or cells set-many;

package/dench.ts

@@ -478,6 +478,13 @@ CRM (Daytona-native rewrite):
   Batch write helpers: entries create-many/update-many, cells set-many
   Help: dench crm help
 
+Workspace members (for CRM \`user\`-type fields):
+  dench members list [--json]                  (top-level alias)
+  dench crm members list [--json]              (canonical CRM-scoped name)
+      Look up real userIds for the active org so \`Owner\` / \`Assignee\`
+      cells assign to real members instead of being stored as unlinked
+      display-name strings. See \`dench members help\`.
+
 Live web search (Exa via the Dench Cloud Gateway, auths with DENCH_API_KEY):
   dench search "<query>" [--num-results N] [--type auto|fast|deep|deep-reasoning|neural] [--category news|company|people|...] [--include-domains a.com,b.com] [--exclude-domains c.com] [--max-chars 800] [--json]
   dench search contents <url> [<url>...] [--max-chars 4000] [--summary "..."] [--json]
@@ -3272,6 +3279,46 @@ async function main() {
     return;
   }
 
+  if (command === "members") {
+    // Top-level convenience surface for the same Convex query that
+    // `dench crm members list` calls. Lives here (rather than only
+    // under `dench crm`) so it shows up in top-level help and tab
+    // completion — members aren't strictly a CRM concept, even though
+    // the canonical caller today is the AI agent looking up userIds
+    // for `user`-typed CRM cells.
+    const subArgs = stripRuntimeFlags(args.slice(args.indexOf("members") + 1));
+    const sub = subArgs[0];
+    if (!sub || sub === "help" || sub === "--help") {
+      const { runMembersCommand } = await import("./members");
+      // biome-ignore lint/suspicious/noExplicitAny: harmless help-only stub
+      await runMembersCommand({ convex: {} as any, args: subArgs });
+      return;
+    }
+    const { runMembersCommand } = await import("./members");
+    const runtime = await getRuntime();
+    // Member listing is org-scoped via `requireCrmAccess`, identical
+    // auth shape to `dench crm`. Dev workspaces forward the encoded
+    // dev token so local --dev runs work the same way.
+    if (runtime.mode === "dev") {
+      await runMembersCommand({
+        convex: runtime.client,
+        args: subArgs,
+        sessionToken: encodeDevCrmSessionToken(runtime.workspaceArgs),
+      });
+      return;
+    }
+    const authedRuntime = requireAuthenticatedRuntime(
+      runtime,
+      "dench members",
+    );
+    await runMembersCommand({
+      convex: authedRuntime.client,
+      args: subArgs,
+      sessionToken: authedRuntime.sessionToken,
+    });
+    return;
+  }
+
   if (command === "fs") {
     await runFsCommand();
     return;