@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/server-ISwlDRCN.mjs

@@ -0,0 +1,242 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { t as toCliError } from "../agentcrm.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+const SUPPORTED_PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const LATEST_PROTOCOL = SUPPORTED_PROTOCOLS[0];
+const RPC = { parse: -32700, invalidRequest: -32600, methodNotFound: -32601, invalidParams: -32602, internal: -32603 };
+const DESTRUCTIVE = /* @__PURE__ */ new Set(["delete_record", "merge_records", "import_csv", "update_record"]);
+const IDEMPOTENT = /* @__PURE__ */ new Set(["update_record", "move_deal_stage", "complete_task"]);
+const PROMPTS = [
+  {
+    name: "pipeline_review",
+    title: "Pipeline review",
+    description: "Review the sales pipeline: totals by stage, forecast, stale deals and the next best action per deal.",
+    arguments: [
+      { name: "pipelineId", description: "Pipeline id (default: the main one).", required: false },
+      { name: "ownerId", description: "Only this owner's deals.", required: false }
+    ],
+    render: (a) => [
+      "Review my sales pipeline in the CRM.",
+      `1. Call pipeline_summary${a.pipelineId || a.ownerId ? ` with ${JSON.stringify({ ...a.pipelineId ? { pipelineId: a.pipelineId } : {}, ...a.ownerId ? { ownerId: a.ownerId } : {} })}` : ""} for totals per stage and the weighted forecast.`,
+      '2. Call run_report with { "name": "staleDeals" } to find open deals without recent activity.',
+      "3. For the 5 largest open deals, call get_record (and list_activities) to read their latest activity and open tasks.",
+      "4. Answer with: a short summary (open amount, weighted amount, what changed), a table of deals at risk (stale, close date passed, no next step), and ONE concrete next best action per deal (call, email, meeting, update the close date…).",
+      "Do not change anything in the CRM unless I confirm; offer to create the follow-up tasks with create_task."
+    ].join("\n")
+  },
+  {
+    name: "follow_up_email",
+    title: "Follow-up email draft",
+    description: "Draft a follow-up email for a person, company or deal from its CRM timeline.",
+    arguments: [
+      { name: "recordId", description: "Record id (person, company or deal).", required: true },
+      { name: "goal", description: "What the email should achieve (e.g. book a demo, send the proposal).", required: false },
+      { name: "tone", description: "Tone (default: friendly and concise).", required: false }
+    ],
+    render: (a) => [
+      `Draft a follow-up email for CRM record ${a.recordId}.`,
+      `1. Call get_record with { "id": "${a.recordId}" } and list_activities with { "recordId": "${a.recordId}", "includeRelated": true } to learn who they are, what was discussed and what is pending.`,
+      `2. Write the email${a.goal ? ` with this goal: ${a.goal}` : " that moves the relationship to its next step"}, tone: ${a.tone || "friendly, concise, specific"}. Reference concrete facts from the timeline; never invent facts, prices or commitments.`,
+      "3. Show me the subject and body. Only after I approve, offer to log it with log_activity (type email) and to create a follow-up task with create_task."
+    ].join("\n")
+  },
+  {
+    name: "lead_qualification",
+    title: "Lead qualification",
+    description: "Qualify a lead (BANT-style) from the CRM data and suggest the lifecycle stage and next step.",
+    arguments: [{ name: "recordId", description: "Person or company record id.", required: true }],
+    render: (a) => [
+      `Qualify the lead ${a.recordId}.`,
+      `1. Call describe_schema (object "people") to learn the lifecycle stages, then get_record with { "id": "${a.recordId}" } and list_activities for its history.`,
+      "2. Assess Budget, Authority, Need and Timing from what the CRM knows; list what is unknown and the questions to ask.",
+      "3. Recommend a lifecycleStage (subscriber, lead, mql, sql, opportunity…) with a one-line justification, a fit score from 1 to 5 and the next best action.",
+      "4. Only after I confirm: update_record with the new lifecycleStage and add_note with the qualification summary."
+    ].join("\n")
+  }
+];
+const RESOURCES = [
+  { uri: "agentcrm://schema", name: "schema", title: "CRM data model", description: "Objects, fields (ids, types, select options, relations) and pipelines.", mimeType: "application/json" },
+  { uri: "agentcrm://pipelines", name: "pipelines", title: "Pipelines", description: "Pipelines with stages, probabilities and the current forecast.", mimeType: "application/json" },
+  { uri: "agentcrm://modules", name: "modules", title: "Modules", description: "Workspace modules (built-in and extensions) with enabled / required state and dependencies, plus the installed extensions.", mimeType: "application/json" },
+  { uri: "agentcrm://appearance", name: "appearance", title: "Appearance", description: "The effective workspace appearance (accent, neutral, radius, density, font, sidebar, mode, theme) and the available presets / themes.", mimeType: "application/json" }
+];
+function toolAnnotations(tool) {
+  return {
+    title: tool.name.replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase()),
+    readOnlyHint: !tool.mutating,
+    destructiveHint: tool.mutating && DESTRUCTIVE.has(tool.name),
+    idempotentHint: !tool.mutating || IDEMPOTENT.has(tool.name),
+    openWorldHint: false
+  };
+}
+function createMcpServer(opts) {
+  const all = () => typeof opts.tools === "function" ? opts.tools() : opts.tools;
+  const visible = () => all().filter((t) => !(opts.readOnly && t.mutating));
+  let initialized = false;
+  let protocol = LATEST_PROTOCOL;
+  const ok = (id, result) => ({ jsonrpc: "2.0", id, result });
+  const fail = (id, code, message, data) => ({ jsonrpc: "2.0", id, error: { code, message, ...data !== void 0 ? { data } : {} } });
+  async function callTool(id, params) {
+    const name = typeof params.name === "string" ? params.name : "";
+    const tool = all().find((t) => t.name === name);
+    if (!tool) return fail(id, RPC.invalidParams, `Unknown tool: ${name}`);
+    if (opts.readOnly && tool.mutating) return fail(id, RPC.invalidParams, `Tool ${name} changes data and this server is read-only.`);
+    const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+    try {
+      const run = async () => {
+        const ctx = await opts.backend.context();
+        const { callTool: call } = await import("./tools-Bew8lxKx.mjs");
+        return call(ctx, name, args);
+      };
+      const result = tool.mutating ? await opts.backend.withWrite(run) : await run();
+      const structured = result && typeof result === "object" && !Array.isArray(result) ? result : { result: result ?? null };
+      return ok(id, { content: [{ type: "text", text: JSON.stringify(result ?? null, null, 2) }], structuredContent: structured, isError: false });
+    } catch (err) {
+      const e = toCliError(err);
+      const error = { code: e.code, message: e.message, ...e.hint ? { hint: e.hint } : {} };
+      return ok(id, { content: [{ type: "text", text: JSON.stringify({ error }) }], structuredContent: { error }, isError: true });
+    }
+  }
+  async function readResource(id, uri) {
+    const ctx = await opts.backend.context();
+    let value;
+    if (uri === "agentcrm://schema") value = (await import("./schema-DlHt2PxI.mjs")).describeSchema(ctx);
+    else if (uri === "agentcrm://pipelines") {
+      const { listPipelines, forecast } = await import("./pipelines-DCdRBNBV.mjs");
+      value = listPipelines(ctx).map((p) => ({ ...p, forecast: forecast(ctx, { pipelineId: p.id }) }));
+    } else if (uri === "agentcrm://modules") {
+      const [{ listModules }, { listExtensions }] = await Promise.all([import("./modules-CqdVQVJb.mjs"), import("./extensions-BP1k60md.mjs")]);
+      value = { modules: listModules(ctx), extensions: listExtensions(ctx) };
+    } else if (uri === "agentcrm://appearance") {
+      const { getAppearance, listPresets } = await import("./appearance-BaShelzt.mjs");
+      const { logo, favicon, customCss, ...rest } = getAppearance(ctx);
+      value = { appearance: { ...rest, hasLogo: !!logo, hasFavicon: !!favicon, customCss: customCss ?? null }, presets: listPresets(ctx).map((p) => ({ id: p.id, name: p.name, source: p.source, description: p.description, ...p.enabled !== void 0 ? { enabled: p.enabled } : {} })) };
+    } else return fail(id, -32002, `Resource not found: ${uri}`, { uri });
+    return ok(id, { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(value, null, 2) }] });
+  }
+  async function handle(msg) {
+    if (!msg || typeof msg !== "object" || msg.jsonrpc !== "2.0" || typeof msg.method !== "string") {
+      const id2 = msg && typeof msg === "object" && "id" in msg ? msg.id ?? null : null;
+      return fail(id2, RPC.invalidRequest, "Invalid JSON-RPC 2.0 request.");
+    }
+    const req = msg;
+    const isNotification = !("id" in req) || req.id === void 0;
+    const id = req.id ?? null;
+    const params = req.params ?? {};
+    if (isNotification) {
+      if (req.method === "notifications/initialized") initialized = true;
+      return null;
+    }
+    try {
+      switch (req.method) {
+        case "initialize": {
+          const requested = typeof params.protocolVersion === "string" ? params.protocolVersion : LATEST_PROTOCOL;
+          protocol = SUPPORTED_PROTOCOLS.includes(requested) ? requested : LATEST_PROTOCOL;
+          return ok(id, {
+            protocolVersion: protocol,
+            capabilities: { tools: { listChanged: false }, resources: { listChanged: false, subscribe: false }, prompts: { listChanged: false }, logging: {} },
+            serverInfo: { name: opts.backend.serverName, title: "AgentCRM", version: opts.backend.version },
+            instructions: `AgentCRM (${opts.backend.siteLabel})${opts.readOnly ? " — READ-ONLY" : ""}. Call describe_schema first to learn object and field ids. Search before creating to avoid duplicates. Mutating tools change the user's CRM: confirm destructive actions (delete, merge, import with confirm: true) with the user first.`
+          });
+        }
+        case "ping":
+          return ok(id, {});
+        case "tools/list":
+          return ok(id, {
+            tools: visible().map((t) => ({ name: t.name, title: toolAnnotations(t).title, description: t.description, inputSchema: t.inputSchema, annotations: toolAnnotations(t) }))
+          });
+        case "tools/call":
+          return callTool(id, params);
+        case "resources/list":
+          return ok(id, { resources: RESOURCES });
+        case "resources/templates/list":
+          return ok(id, { resourceTemplates: [] });
+        case "resources/read":
+          return readResource(id, typeof params.uri === "string" ? params.uri : "");
+        case "prompts/list":
+          return ok(id, { prompts: PROMPTS.map(({ render: _render, ...p }) => p) });
+        case "prompts/get": {
+          const prompt = PROMPTS.find((p) => p.name === params.name);
+          if (!prompt) return fail(id, RPC.invalidParams, `Unknown prompt: ${String(params.name)}`);
+          const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+          const missing = prompt.arguments.filter((a) => a.required && !args[a.name]);
+          if (missing.length) return fail(id, RPC.invalidParams, `Missing argument(s): ${missing.map((a) => a.name).join(", ")}`);
+          return ok(id, { description: prompt.description, messages: [{ role: "user", content: { type: "text", text: prompt.render(args) } }] });
+        }
+        case "logging/setLevel":
+          return ok(id, {});
+        default:
+          return fail(id, RPC.methodNotFound, `Method not found: ${req.method}`);
+      }
+    } catch (err) {
+      return fail(id, RPC.internal, err.message);
+    }
+  }
+  return {
+    handle,
+    get initialized() {
+      return initialized;
+    },
+    get protocol() {
+      return protocol;
+    },
+    toolNames: () => visible().map((t) => t.name)
+  };
+}
+function serveStdio(server, input, write, log = () => void 0) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let chain = Promise.resolve();
+    const processLine = async (line) => {
+      if (!line.trim()) return;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        write(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: RPC.parse, message: "Parse error" } }));
+        return;
+      }
+      if (Array.isArray(msg)) {
+        const out = (await Promise.all(msg.map((m) => server.handle(m)))).filter((r) => r !== null);
+        if (out.length) write(JSON.stringify(out));
+        return;
+      }
+      const res = await server.handle(msg);
+      if (res) write(JSON.stringify(res));
+    };
+    input.setEncoding?.("utf8");
+    input.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).replace(/\r$/, "");
+        buffer = buffer.slice(nl + 1);
+        chain = chain.then(() => processLine(line)).catch((err) => log(`[mcp] ${err.message}`));
+      }
+    });
+    input.on("end", () => {
+      const rest = buffer;
+      buffer = "";
+      chain = chain.then(() => processLine(rest)).finally(() => resolve());
+    });
+  });
+}
+export {
+  LATEST_PROTOCOL,
+  RPC,
+  SUPPORTED_PROTOCOLS,
+  createMcpServer,
+  serveStdio
+};

package/dist/agent/chunks/settings-BtvR_jdm.mjs

@@ -0,0 +1,76 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { OpsError, assertCan } from "./context-CxFfqS4D.mjs";
+import { settingsDoc, asDoc } from "./store-5gqRSKXg.mjs";
+import { SECRET_SETTING_KEYS } from "./runtimeConfig-CCOFg1RM.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+const DEFAULT_SETTINGS = {
+  id: "general",
+  name: "AgentCRM",
+  defaultCurrency: "USD",
+  locale: "en-US",
+  weekStartsOn: 1,
+  staleDealDays: 14
+};
+function getSettings(ctx) {
+  assertCan(ctx, "settings.read");
+  return { ...DEFAULT_SETTINGS, ...settingsDoc(ctx.store) ?? {} };
+}
+async function updateSettings(ctx, patch) {
+  assertCan(ctx, "settings.write");
+  if (patch.defaultCurrency !== void 0 && !/^[A-Z]{3}$/.test(patch.defaultCurrency.toUpperCase())) {
+    throw new OpsError("validation", `"${patch.defaultCurrency}" is not an ISO 4217 currency code.`);
+  }
+  if (patch.staleDealDays !== void 0 && (!Number.isFinite(patch.staleDealDays) || patch.staleDealDays < 1)) {
+    throw new OpsError("validation", "Stale deal days must be a positive number.");
+  }
+  if (patch.maxUploadMb !== void 0 && (!Number.isFinite(patch.maxUploadMb) || patch.maxUploadMb < 1 || patch.maxUploadMb > 1024)) {
+    throw new OpsError("validation", "Max upload size must be between 1 and 1024 MB.");
+  }
+  const current = getSettings(ctx);
+  const next = {
+    ...current,
+    ...Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0)),
+    ...patch.defaultCurrency ? { defaultCurrency: patch.defaultCurrency.toUpperCase() } : {},
+    id: "general",
+    updatedAt: ctx.now(),
+    createdAt: current.createdAt ?? ctx.now()
+  };
+  await ctx.store.write([{ op: "set", collection: "settings", doc: asDoc(next) }], { message: "Update settings" });
+  return getSettings(ctx);
+}
+function assertNoSecrets(value, path = "") {
+  if (!value || typeof value !== "object") return;
+  for (const [k, v] of Object.entries(value)) {
+    if (SECRET_SETTING_KEYS.has(k) && v !== "" && v != null) {
+      throw new OpsError("validation", `Refusing to store the secret "${path}${k}" in the CRM data. Keep secrets in this browser / the CLI credentials.`);
+    }
+    assertNoSecrets(v, `${path}${k}.`);
+  }
+}
+function getConfigDoc(ctx, id) {
+  assertCan(ctx, "settings.read");
+  return ctx.store.get("config", id);
+}
+async function setConfigDoc(ctx, id, value) {
+  assertCan(ctx, "settings.write");
+  if (value === null) {
+    await ctx.store.write([{ op: "delete", collection: "config", id }], { message: `Remove config ${id}` });
+    return;
+  }
+  assertNoSecrets(value);
+  const doc = { ...value, id };
+  await ctx.store.write([{ op: "set", collection: "config", doc: asDoc(doc) }], { message: `Update config ${id}` });
+}
+export {
+  DEFAULT_SETTINGS,
+  assertNoSecrets,
+  getConfigDoc,
+  getSettings,
+  setConfigDoc,
+  updateSettings
+};

package/dist/agent/chunks/standardObjects-CheqfDqa.mjs

@@ -0,0 +1,243 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { normalizeDomain, colorAt } from "./fields-B0bitgmr.mjs";
+const DEFAULT_PIPELINE_ID = "sales";
+function options(labels) {
+  return labels.map((l, i) => {
+    const [id, label] = Array.isArray(l) ? l : [l.toLowerCase().replace(/[^a-z0-9]+/g, "-"), l];
+    return { id, label, color: colorAt(i) };
+  });
+}
+const INDUSTRY_OPTIONS = options([
+  "Software",
+  "Finance",
+  "Healthcare",
+  "Retail",
+  "Manufacturing",
+  "Education",
+  "Media",
+  "Consulting",
+  ["real-estate", "Real estate"],
+  "Other"
+]);
+const LIFECYCLE_OPTIONS = [
+  { id: "subscriber", label: "Subscriber", color: "gray" },
+  { id: "lead", label: "Lead", color: "blue" },
+  { id: "mql", label: "MQL", color: "teal" },
+  { id: "sql", label: "SQL", color: "indigo" },
+  { id: "opportunity", label: "Opportunity", color: "orange" },
+  { id: "customer", label: "Customer", color: "green" },
+  { id: "evangelist", label: "Evangelist", color: "purple" }
+];
+const LEAD_SOURCE_OPTIONS = options(["Website", "Referral", "Event", "Outbound", "Partner", "Ads", "Social", "Other"]);
+const DEFAULT_STAGES = [
+  { id: "new", label: "New", color: "gray", probability: 10, kind: "open" },
+  { id: "qualified", label: "Qualified", color: "blue", probability: 25, kind: "open" },
+  { id: "proposal", label: "Proposal", color: "purple", probability: 50, kind: "open" },
+  { id: "negotiation", label: "Negotiation", color: "orange", probability: 75, kind: "open" },
+  { id: "won", label: "Won", color: "green", probability: 100, kind: "won" },
+  { id: "lost", label: "Lost", color: "red", probability: 0, kind: "lost" }
+];
+function defaultPipeline() {
+  return {
+    id: DEFAULT_PIPELINE_ID,
+    object: "deals",
+    name: "Sales",
+    stageField: "stage",
+    stages: DEFAULT_STAGES.map((s) => ({ ...s }))
+  };
+}
+const f = (def) => ({ standard: true, ...def });
+function companiesObject(now) {
+  return {
+    id: "companies",
+    labelSingular: "Company",
+    labelPlural: "Companies",
+    icon: "Building2",
+    color: "blue",
+    standard: true,
+    labelField: "name",
+    imageField: "logo",
+    createdAt: now,
+    updatedAt: now,
+    fields: [
+      f({ id: "name", label: "Name", type: "text", required: true, system: true }),
+      f({ id: "domain", label: "Domain", type: "url", unique: true, description: "Main website — used to deduplicate companies." }),
+      f({ id: "industry", label: "Industry", type: "select", options: INDUSTRY_OPTIONS.map((o) => ({ ...o })) }),
+      f({ id: "employees", label: "Employees", type: "number" }),
+      f({ id: "annualRevenue", label: "Annual revenue", type: "currency", currency: "USD" }),
+      f({ id: "address", label: "Address", type: "address" }),
+      f({ id: "linkedin", label: "LinkedIn", type: "url" }),
+      f({ id: "phone", label: "Phone", type: "phone" }),
+      f({ id: "tags", label: "Tags", type: "tags" }),
+      f({ id: "logo", label: "Logo", type: "image", description: "Company logo shown next to its name." })
+    ]
+  };
+}
+function peopleObject(now) {
+  return {
+    id: "people",
+    labelSingular: "Person",
+    labelPlural: "People",
+    icon: "User",
+    color: "purple",
+    standard: true,
+    labelField: "name",
+    imageField: "avatar",
+    createdAt: now,
+    updatedAt: now,
+    fields: [
+      f({ id: "firstName", label: "First name", type: "text" }),
+      f({ id: "lastName", label: "Last name", type: "text" }),
+      f({ id: "name", label: "Name", type: "text", system: true, description: "Full name — kept in sync with first and last name." }),
+      f({ id: "email", label: "Email", type: "email", unique: true }),
+      f({ id: "phone", label: "Phone", type: "phone" }),
+      f({ id: "jobTitle", label: "Job title", type: "text" }),
+      f({ id: "company", label: "Company", type: "relation", relation: { object: "companies", cardinality: "one", inverseField: "people" } }),
+      f({ id: "city", label: "City", type: "text" }),
+      f({ id: "linkedin", label: "LinkedIn", type: "url" }),
+      f({ id: "lifecycleStage", label: "Lifecycle stage", type: "select", options: LIFECYCLE_OPTIONS.map((o) => ({ ...o })), defaultValue: "lead" }),
+      f({ id: "leadSource", label: "Lead source", type: "select", options: LEAD_SOURCE_OPTIONS.map((o) => ({ ...o })) }),
+      f({ id: "tags", label: "Tags", type: "tags" }),
+      f({ id: "avatar", label: "Photo", type: "image", description: "Profile picture shown next to the name." })
+    ]
+  };
+}
+function dealsObject(now, pipelines = [defaultPipeline()]) {
+  return {
+    id: "deals",
+    labelSingular: "Deal",
+    labelPlural: "Deals",
+    icon: "Handshake",
+    color: "green",
+    standard: true,
+    labelField: "name",
+    createdAt: now,
+    updatedAt: now,
+    fields: [
+      f({ id: "name", label: "Name", type: "text", required: true, system: true }),
+      f({ id: "amount", label: "Amount", type: "currency", currency: "USD" }),
+      f({ id: "stage", label: "Stage", type: "select", system: true, options: stageOptions(pipelines), defaultValue: pipelines[0]?.stages[0]?.id }),
+      f({ id: "pipeline", label: "Pipeline", type: "select", system: true, options: pipelineOptions(pipelines), defaultValue: pipelines[0]?.id }),
+      f({ id: "closeDate", label: "Close date", type: "date" }),
+      f({ id: "probability", label: "Probability", type: "percent" }),
+      f({ id: "company", label: "Company", type: "relation", relation: { object: "companies", cardinality: "one", inverseField: "deals" } }),
+      f({ id: "contacts", label: "Contacts", type: "relation", relation: { object: "people", cardinality: "many", inverseField: "deals" } }),
+      f({ id: "lostReason", label: "Lost reason", type: "text" })
+    ]
+  };
+}
+function stageOptions(pipelines) {
+  return pipelines.flatMap((p) => p.stages.map((s) => ({ id: s.id, label: s.label, color: s.color })));
+}
+function pipelineOptions(pipelines) {
+  return pipelines.map((p, i) => ({ id: p.id, label: p.name, color: colorAt(i + 1) }));
+}
+const STANDARD_IMAGE_FIELDS = { companies: "logo", people: "avatar" };
+function standardObjects(now) {
+  return [companiesObject(now), peopleObject(now), dealsObject(now)];
+}
+function defaultViews() {
+  return [
+    {
+      id: "companies-all",
+      object: "companies",
+      name: "All companies",
+      type: "table",
+      columns: ["name", "domain", "industry", "employees", "annualRevenue", "tags"],
+      filters: [],
+      sorts: [{ field: "name", dir: "asc" }],
+      shared: true
+    },
+    {
+      id: "people-all",
+      object: "people",
+      name: "All people",
+      type: "table",
+      columns: ["name", "email", "company", "jobTitle", "lifecycleStage", "leadSource", "city"],
+      filters: [],
+      sorts: [{ field: "name", dir: "asc" }],
+      shared: true
+    },
+    {
+      id: "deals-all",
+      object: "deals",
+      name: "All deals",
+      type: "table",
+      columns: ["name", "amount", "stage", "closeDate", "company", "contacts", "probability"],
+      filters: [],
+      sorts: [{ field: "closeDate", dir: "asc" }],
+      shared: true
+    },
+    {
+      id: "deals-pipeline",
+      object: "deals",
+      name: "Pipeline",
+      type: "kanban",
+      columns: ["name", "amount", "company", "closeDate"],
+      filters: [{ field: "pipeline", op: "eq", value: DEFAULT_PIPELINE_ID }],
+      sorts: [{ field: "amount", dir: "desc" }],
+      groupBy: "stage",
+      pipelineId: DEFAULT_PIPELINE_ID,
+      shared: true
+    }
+  ];
+}
+function defaultViewFor(object) {
+  return {
+    id: `${object.id}-all`,
+    object: object.id,
+    name: `All ${object.labelPlural.toLowerCase()}`,
+    type: "table",
+    columns: object.fields.filter((fd) => !fd.hidden && fd.type !== "image").slice(0, 7).map((fd) => fd.id),
+    filters: [],
+    sorts: [],
+    shared: true
+  };
+}
+function normalizeStandardFields(objectId, next, previous) {
+  if (objectId === "people") {
+    const out = { ...next };
+    const first = str(out.firstName);
+    const last = str(out.lastName);
+    const name = str(out.name);
+    const prevDerived = previous ? [str(previous.firstName), str(previous.lastName)].filter(Boolean).join(" ") : "";
+    const partsChanged = !!previous && (str(previous.firstName) !== first || str(previous.lastName) !== last);
+    if (first || last) {
+      if (!name || partsChanged && name === prevDerived) out.name = [first, last].filter(Boolean).join(" ");
+    } else if (name) {
+      const parts = name.split(/\s+/);
+      out.firstName = parts[0];
+      if (parts.length > 1) out.lastName = parts.slice(1).join(" ");
+    }
+    return out;
+  }
+  if (objectId === "companies") {
+    const out = { ...next };
+    if (!str(out.name) && str(out.domain)) {
+      const d = normalizeDomain(out.domain);
+      const base = d.split(".")[0] ?? "";
+      if (base) out.name = base[0].toUpperCase() + base.slice(1);
+    }
+    return out;
+  }
+  return next;
+}
+function str(v) {
+  return typeof v === "string" ? v.trim() : "";
+}
+export {
+  LIFECYCLE_OPTIONS as L,
+  STANDARD_IMAGE_FIELDS as S,
+  standardObjects as a,
+  defaultPipeline as b,
+  defaultViews as c,
+  defaultViewFor as d,
+  normalizeStandardFields as n,
+  pipelineOptions as p,
+  stageOptions as s
+};

package/dist/agent/chunks/stats-CfeJssSS.mjs

@@ -0,0 +1,51 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { A as ACTIVITY_TYPES } from "../agentcrm.mjs";
+import { assertCan } from "./context-CxFfqS4D.mjs";
+import { forecast } from "./pipelines-DCdRBNBV.mjs";
+import { activitiesOf, pipelinesOf, usersOf, objectsOf, recordsOf } from "./store-5gqRSKXg.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./fields-B0bitgmr.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./records-DoqiT9xR.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./relations-B9TynBmA.mjs";
+function getStats(ctx) {
+  assertCan(ctx, "reports.read");
+  const now = ctx.now();
+  const activities = activitiesOf(ctx.store);
+  const byType = Object.fromEntries(ACTIVITY_TYPES.map((t) => [t, 0]));
+  for (const a of activities) byType[a.type]++;
+  const tasks = activities.filter((a) => a.type === "task" && !a.doneAt);
+  const firstPipeline = pipelinesOf(ctx.store, "deals")[0] ?? pipelinesOf(ctx.store)[0];
+  const f = firstPipeline ? forecast(ctx, { pipelineId: firstPipeline.id }) : null;
+  return {
+    objects: objectsOf(ctx.store).map((o) => {
+      const all = recordsOf(ctx.store, o.id, { includeDeleted: true });
+      const deleted = all.filter((r) => r.deletedAt).length;
+      return { id: o.id, label: o.labelPlural, count: all.length - deleted, deleted };
+    }),
+    activities: byType,
+    openTasks: tasks.length,
+    overdueTasks: tasks.filter((t) => t.dueAt !== void 0 && t.dueAt < now).length,
+    users: usersOf(ctx.store).filter((u) => !u.disabled).length,
+    pipeline: f ? { pipelineId: f.pipelineId, openCount: f.openCount, openAmount: f.openAmount, weightedAmount: f.weightedAmount } : null,
+    backend: ctx.store.kind
+  };
+}
+export {
+  getStats
+};