@maestrogtm/maestro-gtm 0.10.16

package/dist/maestro-N7Q2JX22.js

@@ -0,0 +1,903 @@
+import {
+  applyPersonaBoost,
+  parseCountry,
+  parseTitle,
+  resolvePersona
+} from "./chunk-MFFACSBE.js";
+import {
+  getSupabase,
+  resolveOwner
+} from "./chunk-FG43GILY.js";
+import {
+  assembleContext,
+  buildProposal,
+  changelog_service_exports,
+  clusterEntriesByTopic,
+  competitor_service_exports,
+  edge_service_exports,
+  extractOntology,
+  loadExistingEntityNames,
+  loadExistingGraphSummary,
+  outcome_service_exports,
+  persona_repo_exports,
+  persona_service_exports,
+  product_service_exports,
+  proof_point_service_exports,
+  segment_service_exports,
+  source_document_service_exports
+} from "./chunk-SPWDMOEU.js";
+import {
+  createGtmError
+} from "./chunk-UBJUBYSQ.js";
+import {
+  HarvestClient
+} from "./chunk-WKLCPIFB.js";
+import {
+  logError
+} from "./chunk-6GLLK5KO.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/handlers/maestro.ts
+async function handleMaestro(name, args) {
+  const supabase = getSupabase();
+  const owner = resolveOwner(args);
+  const action = name === "intel" ? args.action : name.startsWith("intel_") ? name.slice(6) : name;
+  switch (action) {
+    case "context":
+      return handleGetContext(supabase, owner, args);
+    case "product":
+      return handleUpsertProduct(supabase, owner, args);
+    case "persona":
+      return handleUpsertPersona(supabase, owner, args);
+    case "get_persona":
+      return handleGetPersona(supabase, owner, args);
+    case "segment":
+      return handleUpsertSegment(supabase, owner, args);
+    case "proof":
+      return handleAddProofPoint(supabase, owner, args);
+    case "competitor":
+      return handleAddCompetitor(supabase, owner, args);
+    case "outcome":
+      return handleRecordOutcome(supabase, owner, args);
+    case "gaps":
+      return handleGetGaps(supabase, owner, args);
+    case "propose":
+      return handleProposeGraph(supabase, owner, args);
+    case "ingest":
+      return handleIngestDocument(supabase, owner, args);
+    case "ingest_linkedin":
+      return handleIngestLinkedIn(supabase, owner, args);
+    case "refresh_competitor":
+      return handleRefreshCompetitor(supabase, owner, args);
+    case "changelog":
+      return handleGetChangelog(supabase, owner, args);
+    case "score":
+      return handleScoreContact(supabase, owner, args);
+    default:
+      throw new Error(`Unknown intel action: ${action}`);
+  }
+}
+async function handleGetContext(supabase, owner, args) {
+  const strategy = args.strategy;
+  const query = args.query;
+  const persona_id = args.persona_id;
+  return assembleContext(supabase, {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    strategy,
+    query,
+    persona_id
+  });
+}
+async function handleUpsertProduct(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    name: args.name,
+    description: args.description,
+    category: args.category,
+    value_proposition: args.value_proposition,
+    key_features: args.key_features,
+    pricing_summary: args.pricing_summary
+  };
+  return product_service_exports.upsertProduct(supabase, input);
+}
+async function handleUpsertPersona(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    name: args.name,
+    title_patterns: args.title_patterns,
+    industries: args.industries,
+    company_size_min: args.company_size_min,
+    company_size_max: args.company_size_max,
+    pain_points: args.pain_points,
+    goals: args.goals,
+    objections: args.objections,
+    buying_signals: args.buying_signals,
+    geographic_focus: args.geographic_focus,
+    budget_range: args.budget_range,
+    is_primary: args.is_primary
+  };
+  return persona_service_exports.upsertPersona(supabase, input);
+}
+async function handleGetPersona(supabase, owner, args) {
+  const personaId = args.persona_id;
+  if (personaId) {
+    return persona_service_exports.getPersona(supabase, owner.owner_id, owner.owner_type, personaId);
+  }
+  return persona_service_exports.getPrimaryPersona(supabase, owner.owner_id, owner.owner_type);
+}
+async function handleUpsertSegment(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    name: args.name,
+    description: args.description,
+    qualification_criteria: args.qualification_criteria,
+    market_size_estimate: args.market_size_estimate
+  };
+  return segment_service_exports.upsertSegment(supabase, input);
+}
+async function handleAddProofPoint(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    type: args.type,
+    title: args.title,
+    content: args.content,
+    metric_value: args.metric_value,
+    source_type: args.source_type,
+    source_id: args.source_id
+  };
+  const result = await proof_point_service_exports.addProofPoint(supabase, input);
+  if (result.success && result.data) {
+    const proofPointId = result.data.id;
+    if (args.persona_id) {
+      try {
+        await edge_service_exports.createEdge(supabase, {
+          owner_id: owner.owner_id,
+          owner_type: owner.owner_type,
+          source_type: "proof_point",
+          source_id: proofPointId,
+          target_type: "persona",
+          target_id: args.persona_id,
+          relationship: "supports"
+        });
+      } catch (error) {
+        logError(
+          "maestro.handleAddProofPoint.edgePersona",
+          error instanceof Error ? error : new Error(String(error)),
+          { proofPointId, personaId: args.persona_id }
+        );
+      }
+    }
+    if (args.product_id) {
+      try {
+        await edge_service_exports.createEdge(supabase, {
+          owner_id: owner.owner_id,
+          owner_type: owner.owner_type,
+          source_type: "proof_point",
+          source_id: proofPointId,
+          target_type: "product",
+          target_id: args.product_id,
+          relationship: "demonstrates"
+        });
+      } catch (error) {
+        logError(
+          "maestro.handleAddProofPoint.edgeProduct",
+          error instanceof Error ? error : new Error(String(error)),
+          { proofPointId, productId: args.product_id }
+        );
+      }
+    }
+  }
+  return result;
+}
+async function handleAddCompetitor(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    name: args.name,
+    website: args.website,
+    positioning: args.positioning,
+    strengths: args.strengths,
+    weaknesses: args.weaknesses,
+    differentiation_notes: args.differentiation_notes
+  };
+  return competitor_service_exports.upsertCompetitor(supabase, input);
+}
+async function handleRecordOutcome(supabase, owner, args) {
+  const input = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    outcome_type: args.outcome_type,
+    entity_type: args.entity_type,
+    entity_id: args.entity_id,
+    detail: args.detail,
+    metrics: args.metrics,
+    occurred_at: args.occurred_at ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return outcome_service_exports.recordOutcome(supabase, input);
+}
+async function handleGetGaps(supabase, owner, args) {
+  const personaId = args.persona_id;
+  const context = await assembleContext(supabase, {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    strategy: "campaign_planning",
+    persona_id: personaId
+  });
+  const gaps = [];
+  for (const persona of context.personas) {
+    const linkedEdges = context.edges.filter(
+      (e) => e.target_type === "persona" && e.target_id === persona.id
+    );
+    const linkedProofPoints = linkedEdges.filter((e) => e.source_type === "proof_point");
+    if (linkedProofPoints.length < 2) {
+      gaps.push({
+        entity_type: "persona",
+        entity_name: persona.name,
+        gap: `Only ${linkedProofPoints.length} proof points linked. Need at least 2.`,
+        severity: linkedProofPoints.length === 0 ? "high" : "medium"
+      });
+    }
+    if (persona.objections.length === 0) {
+      gaps.push({
+        entity_type: "persona",
+        entity_name: persona.name,
+        gap: "No objections documented. Record objections from calls and replies.",
+        severity: "medium"
+      });
+    }
+  }
+  for (const product of context.products) {
+    const linkedEdges = context.edges.filter(
+      (e) => e.target_type === "product" && e.target_id === product.id
+    );
+    const linkedProofPoints = linkedEdges.filter((e) => e.source_type === "proof_point");
+    if (linkedProofPoints.length < 3) {
+      gaps.push({
+        entity_type: "product",
+        entity_name: product.name,
+        gap: `Only ${linkedProofPoints.length} proof points. Need at least 3 for credibility.`,
+        severity: linkedProofPoints.length === 0 ? "high" : "medium"
+      });
+    }
+  }
+  if (context.competitors.length === 0) {
+    gaps.push({
+      entity_type: "graph",
+      entity_name: "Competitors",
+      gap: "No competitors documented. Add competitive intelligence for differentiation.",
+      severity: "medium"
+    });
+  }
+  return {
+    persona_count: context.personas.length,
+    product_count: context.products.length,
+    proof_point_count: context.proof_points.length,
+    competitor_count: context.competitors.length,
+    segment_count: context.segments.length,
+    gaps,
+    gap_count: gaps.length,
+    high_severity_count: gaps.filter((g) => g.severity === "high").length
+  };
+}
+function getAnthropicKey() {
+  return process.env.GTM_ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? null;
+}
+var VALID_PROPOSAL_TYPES = [
+  "product",
+  "persona",
+  "segment",
+  "proof_point",
+  "competitor"
+];
+async function handleProposeGraph(supabase, owner, args) {
+  const minEntries = args.min_entries_per_topic ?? 3;
+  const maxClusters = args.max_clusters ?? 20;
+  const summary = await loadExistingGraphSummary(supabase, owner.owner_id, owner.owner_type);
+  const clusters = await clusterEntriesByTopic(supabase, owner.owner_id, owner.owner_type, {
+    minEntries,
+    maxClusters
+  });
+  if (clusters.length === 0) {
+    return {
+      proposals: [],
+      clusters_analyzed: 0,
+      candidates_extracted: 0,
+      candidates_deduplicated: 0,
+      existing_graph_summary: {
+        products: summary.products.count,
+        personas: summary.personas.count,
+        segments: summary.segments.count,
+        proof_points: summary.proof_points.count,
+        competitors: summary.competitors.count
+      },
+      message: `No topic clusters found with ${minEntries}+ entries. Process more transcripts or lower min_entries_per_topic.`
+    };
+  }
+  const apiKey = getAnthropicKey();
+  const allCandidates = [];
+  const existingNames = {
+    products: summary.products.names,
+    personas: summary.personas.names,
+    segments: summary.segments.names,
+    competitors: summary.competitors.names
+  };
+  if (apiKey) {
+    for (let i = 0; i < clusters.length; i++) {
+      const candidates = await extractCandidatesFromCluster(clusters[i], existingNames, apiKey);
+      allCandidates.push(...candidates);
+      if (i < clusters.length - 1) {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+  } else {
+    logError("maestro.handleProposeGraph", new Error("No Anthropic API key configured"), {
+      hint: "Set GTM_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY"
+    });
+  }
+  return buildProposal({
+    candidates: allCandidates,
+    existing_entities: existingNames,
+    proof_points_count: summary.proof_points.count
+  });
+}
+function buildExtractionPrompt(cluster, existingNames) {
+  const entriesText = cluster.entries.map(
+    (e, i) => `[${i + 1}] (${e.category}${e.knowledge_type ? "/" + e.knowledge_type : ""}) ${e.content}`
+  ).join("\n\n");
+  const existingSection = [
+    existingNames.products.length > 0 ? `Products: ${existingNames.products.join(", ")}` : null,
+    existingNames.personas.length > 0 ? `Personas: ${existingNames.personas.join(", ")}` : null,
+    existingNames.segments.length > 0 ? `Segments: ${existingNames.segments.join(", ")}` : null,
+    existingNames.competitors.length > 0 ? `Competitors: ${existingNames.competitors.join(", ")}` : null
+  ].filter(Boolean).join("\n");
+  return `You are analyzing knowledge entries about the topic "${cluster.topic_name}" to identify business entities.
+
+${existingSection ? `EXISTING GRAPH ENTITIES (do NOT re-propose these):
+${existingSection}
+
+` : "No graph entities exist yet.\n\n"}KNOWLEDGE ENTRIES:
+${entriesText}
+
+Identify any NEW entities mentioned in these entries:
+- Products/services being discussed or offered
+- Types of buyers/personas being described (job titles, industries, pain points)
+- Market segments being referenced
+- Proof points: results, metrics, case studies, testimonials cited
+- Competitors being mentioned
+
+For each entity found, return:
+- entity_type: "product" | "persona" | "segment" | "proof_point" | "competitor"
+- name: concise entity name
+- description: 1-2 sentence description based on the entries
+- confidence: 0.0-1.0 (higher = more clearly and frequently referenced)
+- evidence: array of short quoted phrases from entries that support this entity
+- source_entries: array of entry numbers (e.g. [1, 3, 7]) that reference this entity
+
+Return a JSON array. Empty array [] if no new entities found.
+Example: [{"entity_type":"product","name":"GTM Coaching","description":"A coaching program for agency owners","confidence":0.85,"evidence":["our coaching program helps"],"source_entries":[1,3]}]`;
+}
+async function extractCandidatesFromCluster(cluster, existingNames, apiKey) {
+  try {
+    const prompt = buildExtractionPrompt(cluster, existingNames);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 6e4);
+    let result;
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-sonnet-4-5-20250514",
+          max_tokens: 4096,
+          messages: [{ role: "user", content: prompt }]
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({}));
+        logError("maestro.extractCandidates.api", new Error(`Anthropic ${response.status}`), {
+          topic: cluster.topic_slug,
+          body
+        });
+        return [];
+      }
+      const data = await response.json();
+      const text = data.content[0]?.text ?? "";
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) return [];
+      result = JSON.parse(jsonMatch[0]);
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!Array.isArray(result)) return [];
+    const entryIds = cluster.entries.map((e) => e.id);
+    return result.filter(isValidRawCandidate).map((raw) => ({
+      entity_type: raw.entity_type,
+      name: String(raw.name).trim(),
+      description: String(raw.description ?? "").trim(),
+      confidence: Math.max(0, Math.min(1, Number(raw.confidence) || 0.5)),
+      evidence: Array.isArray(raw.evidence) ? raw.evidence.filter((e) => typeof e === "string").map(String) : [],
+      source_topic: cluster.topic_slug,
+      source_entry_ids: Array.isArray(raw.source_entries) ? raw.source_entries.filter((n) => typeof n === "number").map((n) => entryIds[n - 1]).filter(Boolean) : []
+    }));
+  } catch (error) {
+    logError(
+      "maestro.extractCandidatesFromCluster",
+      error instanceof Error ? error : new Error(String(error)),
+      { topic: cluster.topic_slug }
+    );
+    return [];
+  }
+}
+function isValidRawCandidate(raw) {
+  return typeof raw.entity_type === "string" && VALID_PROPOSAL_TYPES.includes(raw.entity_type) && typeof raw.name === "string" && raw.name.trim().length > 0;
+}
+var VALID_MENTION_ENTITY_TYPES = ["product", "persona", "competitor"];
+function buildClassificationPrompt(content, entityNames) {
+  const sections = [];
+  if (entityNames.products.length > 0)
+    sections.push(`Products: ${entityNames.products.join(", ")}`);
+  if (entityNames.personas.length > 0)
+    sections.push(`Personas: ${entityNames.personas.join(", ")}`);
+  if (entityNames.competitors.length > 0)
+    sections.push(`Competitors: ${entityNames.competitors.join(", ")}`);
+  const entityList = sections.join("\n");
+  return `You are an entity mention classifier. Given text content and a list of known business entities, identify which entities are referenced in the text.
+
+KNOWN ENTITIES:
+${entityList}
+
+TEXT CONTENT:
+${content.slice(0, 8e3)}
+
+RULES:
+- ONLY match against the known entities listed above
+- Do NOT invent new entities
+- Match by meaning, not exact string \u2014 "our coaching program" matches a product named "GTM Coaching"
+- For personas, match when the text discusses pain points, goals, or characteristics of that persona type
+- For competitors, match when the text references or compares to that competitor
+- confidence: 0.0-1.0 based on how clearly the entity is referenced
+- evidence: quote the specific phrase(s) that indicate the mention
+
+Respond with ONLY a JSON array of matches (empty array if none):
+[{"entity_type": "product"|"persona"|"competitor", "name": "exact name from the list above", "relationship": "mentions"|"addresses_pain_point"|"references_competitor"|"demonstrates_value"|"overcomes_objection", "confidence": 0.8, "evidence": "quoted phrase"}]`;
+}
+function isValidMention(m) {
+  if (!m || typeof m !== "object") return false;
+  const obj = m;
+  return typeof obj.entity_type === "string" && VALID_MENTION_ENTITY_TYPES.includes(obj.entity_type) && typeof obj.name === "string" && typeof obj.relationship === "string" && typeof obj.confidence === "number" && typeof obj.evidence === "string" && obj.confidence >= 0 && obj.confidence <= 1;
+}
+async function classifyEntityMentionsForGraph(content, entityNames) {
+  const totalEntities = entityNames.products.length + entityNames.personas.length + entityNames.competitors.length;
+  if (totalEntities === 0) return [];
+  const apiKey = getAnthropicKey();
+  if (!apiKey) {
+    logError("maestro.classifyEntityMentions", new Error("No Anthropic API key configured"), {
+      hint: "Set GTM_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY"
+    });
+    return [];
+  }
+  try {
+    const prompt = buildClassificationPrompt(content, entityNames);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-haiku-4-5-20251001",
+          max_tokens: 1024,
+          messages: [{ role: "user", content: prompt }]
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({}));
+        logError("maestro.classifyEntityMentions.api", new Error(`Anthropic ${response.status}`), {
+          body
+        });
+        return [];
+      }
+      const data = await response.json();
+      const text = data.content[0]?.text ?? "";
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) return [];
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(isValidMention);
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch (err) {
+    logError(
+      "maestro.classifyEntityMentionsForGraph",
+      err instanceof Error ? err : new Error(String(err))
+    );
+    return [];
+  }
+}
+async function handleIngestDocument(supabase, owner, args) {
+  const filename = args.filename;
+  const documentType = args.document_type ?? "other";
+  const content = args.content;
+  const docResult = await source_document_service_exports.createDocument(supabase, {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    filename,
+    document_type: documentType
+  });
+  if (!docResult.success) {
+    throw createGtmError(
+      "PROVIDER_REQUEST_FAILED",
+      `Failed to record document: ${docResult.error}`
+    );
+  }
+  const doc = docResult.data;
+  if (!content) {
+    return {
+      success: true,
+      document: doc,
+      edges_created: 0,
+      entities_matched: 0,
+      message: "Document recorded. No content provided \u2014 use content param for automatic extraction."
+    };
+  }
+  await source_document_service_exports.markProcessing(supabase, doc.id);
+  try {
+    const entityNames = await loadExistingEntityNames(supabase, owner.owner_id, owner.owner_type);
+    const mentions = await classifyEntityMentionsForGraph(content, entityNames);
+    let edgesCreated = 0;
+    if (mentions.length > 0) {
+      const result = await extractOntology(supabase, {
+        owner_id: owner.owner_id,
+        owner_type: owner.owner_type,
+        knowledge_entry_id: doc.id,
+        source_type: "source_document",
+        source_id: doc.id,
+        mentions
+      });
+      if (result.success) {
+        edgesCreated = result.data.edges_created;
+      }
+    }
+    await source_document_service_exports.markCompleted(supabase, doc.id, edgesCreated);
+    return {
+      success: true,
+      document: doc,
+      edges_created: edgesCreated,
+      entities_matched: mentions.length,
+      message: `Document processed. ${mentions.length} entity mentions found, ${edgesCreated} edges created.`
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    await source_document_service_exports.markFailed(supabase, doc.id, errorMsg);
+    logError("maestro.handleIngestDocument", err instanceof Error ? err : new Error(String(err)), {
+      filename,
+      docId: doc.id
+    });
+    throw createGtmError("PROVIDER_REQUEST_FAILED", `Document processing failed: ${errorMsg}`);
+  }
+}
+function getHarvestApiKey() {
+  return process.env.GTM_HARVEST_API_KEY ?? null;
+}
+async function handleIngestLinkedIn(supabase, owner, args) {
+  const linkedinUrl = args.linkedin_url;
+  const includePosts = args.include_posts ?? false;
+  const harvestKey = getHarvestApiKey();
+  if (!harvestKey) {
+    throw createGtmError(
+      "PROVIDER_NOT_CONFIGURED",
+      "HarvestAPI key not configured. Set GTM_HARVEST_API_KEY."
+    );
+  }
+  const harvest = new HarvestClient({ apiKey: harvestKey });
+  const profile = await harvest.getProfile(linkedinUrl);
+  const textParts = [];
+  if (profile.headline) textParts.push(profile.headline);
+  if (profile.about) textParts.push(profile.about);
+  if (profile.experience && Array.isArray(profile.experience)) {
+    for (const exp of profile.experience) {
+      const parts = [exp.position, exp.companyName, exp.description].filter(Boolean);
+      if (parts.length > 0) textParts.push(parts.join(" at "));
+    }
+  }
+  if (includePosts) {
+    try {
+      const postsResponse = await harvest.getProfilePosts({ profile: linkedinUrl });
+      if (postsResponse.elements && Array.isArray(postsResponse.elements)) {
+        for (const post of postsResponse.elements.slice(0, 10)) {
+          if (post.content) textParts.push(post.content);
+        }
+      }
+    } catch (err) {
+      logError(
+        "maestro.handleIngestLinkedIn.posts",
+        err instanceof Error ? err : new Error(String(err)),
+        { linkedinUrl }
+      );
+    }
+  }
+  const fullText = textParts.join("\n\n");
+  if (!fullText.trim()) {
+    return {
+      success: true,
+      profile_name: `${profile.firstName ?? ""} ${profile.lastName ?? ""}`.trim(),
+      edges_created: 0,
+      entities_matched: 0,
+      message: "Profile scraped but no classifiable text found."
+    };
+  }
+  const docResult = await source_document_service_exports.createDocument(
+    supabase,
+    {
+      owner_id: owner.owner_id,
+      owner_type: owner.owner_type,
+      filename: linkedinUrl,
+      document_type: "other"
+    },
+    "linkedin_ingester"
+  );
+  if (!docResult.success) {
+    throw createGtmError(
+      "PROVIDER_REQUEST_FAILED",
+      `Failed to record LinkedIn source: ${docResult.error}`
+    );
+  }
+  const doc = docResult.data;
+  await source_document_service_exports.markProcessing(supabase, doc.id);
+  try {
+    const entityNames = await loadExistingEntityNames(supabase, owner.owner_id, owner.owner_type);
+    const mentions = await classifyEntityMentionsForGraph(fullText, entityNames);
+    let edgesCreated = 0;
+    if (mentions.length > 0) {
+      const result = await extractOntology(supabase, {
+        owner_id: owner.owner_id,
+        owner_type: owner.owner_type,
+        knowledge_entry_id: doc.id,
+        source_type: "source_document",
+        source_id: doc.id,
+        mentions
+      });
+      if (result.success) {
+        edgesCreated = result.data.edges_created;
+      }
+    }
+    await source_document_service_exports.markCompleted(supabase, doc.id, edgesCreated);
+    return {
+      success: true,
+      profile_name: `${profile.firstName ?? ""} ${profile.lastName ?? ""}`.trim(),
+      edges_created: edgesCreated,
+      entities_matched: mentions.length,
+      source_document_id: doc.id,
+      message: `LinkedIn profile processed. ${mentions.length} entity mentions, ${edgesCreated} edges.` + (includePosts ? " Posts included." : "")
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    await source_document_service_exports.markFailed(supabase, doc.id, errorMsg);
+    logError("maestro.handleIngestLinkedIn", err instanceof Error ? err : new Error(String(err)), {
+      linkedinUrl,
+      docId: doc.id
+    });
+    throw createGtmError("PROVIDER_REQUEST_FAILED", `LinkedIn ingestion failed: ${errorMsg}`);
+  }
+}
+function getExaApiKey() {
+  return process.env.GTM_EXA_API_KEY ?? null;
+}
+async function handleRefreshCompetitor(supabase, owner, args) {
+  const competitorName = args.competitor_name;
+  const customQuery = args.search_query;
+  if (!competitorName && !customQuery) {
+    throw createGtmError("QUERY_INVALID", "Provide competitor_name and/or search_query.");
+  }
+  const exaKey = getExaApiKey();
+  const anthropicKey = getAnthropicKey();
+  if (!exaKey) {
+    throw createGtmError(
+      "PROVIDER_NOT_CONFIGURED",
+      "Exa API key not configured. Set GTM_EXA_API_KEY."
+    );
+  }
+  if (!anthropicKey) {
+    throw createGtmError(
+      "PROVIDER_NOT_CONFIGURED",
+      "Anthropic API key not configured. Set GTM_ANTHROPIC_API_KEY."
+    );
+  }
+  const searchQuery = customQuery ?? `${competitorName} company positioning pricing features services`;
+  const exaResponse = await fetch("https://api.exa.ai/search", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": exaKey
+    },
+    body: JSON.stringify({
+      query: searchQuery,
+      type: "neural",
+      numResults: 5,
+      contents: {
+        text: { maxCharacters: 2e3 },
+        summary: {
+          query: `What is ${competitorName ?? "this company"}'s positioning, strengths, and weaknesses?`
+        }
+      }
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!exaResponse.ok) {
+    const errText = await exaResponse.text().catch(() => "");
+    throw createGtmError(
+      "PROVIDER_REQUEST_FAILED",
+      `Exa search failed (${exaResponse.status}): ${errText}`
+    );
+  }
+  const exaData = await exaResponse.json();
+  const results = exaData.results ?? [];
+  if (results.length === 0) {
+    return {
+      success: true,
+      competitor_name: competitorName,
+      fields_updated: 0,
+      sources_checked: 0,
+      message: "No search results found."
+    };
+  }
+  const webContent = results.map((r, i) => `[Source ${i + 1}] ${r.title ?? r.url}
+${r.summary ?? ""}
+${r.text ?? ""}`).join("\n\n---\n\n");
+  const extractionPrompt = `Analyze the following web search results about "${competitorName ?? "the company"}".
+Extract structured competitive intelligence.
+
+WEB RESULTS:
+${webContent.slice(0, 6e3)}
+
+Return ONLY a JSON object with these fields (empty string/array if not found):
+{
+  "positioning": "How they position themselves in the market (1-2 sentences)",
+  "strengths": ["strength1", "strength2"],
+  "weaknesses": ["weakness1", "weakness2"],
+  "differentiation_notes": "Key differentiators or unique selling points",
+  "website": "their main website domain if found"
+}`;
+  const aiResponse = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": anthropicKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-haiku-4-5-20251001",
+      max_tokens: 1024,
+      messages: [{ role: "user", content: extractionPrompt }]
+    }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!aiResponse.ok) {
+    throw createGtmError("PROVIDER_REQUEST_FAILED", `AI extraction failed: ${aiResponse.status}`);
+  }
+  const aiData = await aiResponse.json();
+  const aiText = aiData.content[0]?.text ?? "";
+  const jsonMatch = aiText.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    return {
+      success: true,
+      competitor_name: competitorName,
+      fields_updated: 0,
+      sources_checked: results.length,
+      message: "Could not extract structured intel from search results."
+    };
+  }
+  let intel;
+  try {
+    intel = JSON.parse(jsonMatch[0]);
+  } catch (parseErr) {
+    logError(
+      "maestro.refreshCompetitor.parse",
+      parseErr instanceof Error ? parseErr : new Error(String(parseErr)),
+      { competitor_name: competitorName, raw: jsonMatch[0]?.slice(0, 200) }
+    );
+    return {
+      success: true,
+      competitor_name: competitorName,
+      fields_updated: 0,
+      sources_checked: results.length,
+      message: "Failed to parse AI extraction result."
+    };
+  }
+  const upsertInput = {
+    owner_id: owner.owner_id,
+    owner_type: owner.owner_type,
+    name: competitorName ?? (typeof intel.website === "string" ? intel.website : "Unknown")
+  };
+  let fieldsUpdated = 0;
+  if (typeof intel.positioning === "string" && intel.positioning) {
+    upsertInput.positioning = intel.positioning;
+    fieldsUpdated++;
+  }
+  if (Array.isArray(intel.strengths) && intel.strengths.length > 0) {
+    upsertInput.strengths = intel.strengths.filter((s) => typeof s === "string");
+    fieldsUpdated++;
+  }
+  if (Array.isArray(intel.weaknesses) && intel.weaknesses.length > 0) {
+    upsertInput.weaknesses = intel.weaknesses.filter((s) => typeof s === "string");
+    fieldsUpdated++;
+  }
+  if (typeof intel.differentiation_notes === "string" && intel.differentiation_notes) {
+    upsertInput.differentiation_notes = intel.differentiation_notes;
+    fieldsUpdated++;
+  }
+  if (typeof intel.website === "string" && intel.website) {
+    upsertInput.website = intel.website;
+    fieldsUpdated++;
+  }
+  await competitor_service_exports.upsertCompetitor(supabase, upsertInput, "web_scraper");
+  return {
+    success: true,
+    competitor_name: upsertInput.name,
+    fields_updated: fieldsUpdated,
+    sources_checked: results.length,
+    extracted_intel: intel,
+    message: `Competitor "${upsertInput.name}" updated with ${fieldsUpdated} fields from ${results.length} web sources.`
+  };
+}
+async function handleGetChangelog(supabase, owner, args) {
+  const entityId = args.entity_id;
+  const entityType = args.entity_type;
+  if (entityId && entityType) {
+    return changelog_service_exports.getEntityChangelog(
+      supabase,
+      owner.owner_id,
+      owner.owner_type,
+      entityType,
+      entityId
+    );
+  }
+  return changelog_service_exports.getHistory(supabase, owner.owner_id, owner.owner_type, {
+    limit: args.limit ?? 50,
+    entityType,
+    source: args.source
+  });
+}
+async function handleScoreContact(supabase, owner, args) {
+  const headline = args.headline;
+  const location = args.location;
+  const contactSnapshot = {
+    parsed_title: headline ? parseTitle(headline) : null,
+    headline: headline ?? null,
+    location: location ?? null,
+    parsed_country: location ? parseCountry(location) : null,
+    company_name: args.company_name ?? null,
+    company_size: args.company_size ?? null,
+    industry: args.industry ?? null
+  };
+  const personas = await persona_repo_exports.listPersonas(supabase, owner.owner_id, owner.owner_type);
+  const personaMatch = resolvePersona(contactSnapshot, personas);
+  const baseScore = args.base_score ?? 0;
+  const boostResult = applyPersonaBoost(baseScore, personaMatch);
+  return {
+    persona_match: personaMatch,
+    boost: boostResult,
+    personas_checked: personas.length,
+    contact_snapshot: contactSnapshot
+  };
+}
+export {
+  handleMaestro
+};
+//# sourceMappingURL=maestro-N7Q2JX22.js.map