Competitive Intelligence

## COMPETITIVE INTELLIGENCE - SLACK DISCOVERY + SECURITY BATTLE CARD
## Pull competitor mentions from Slack over the last 90 days, research each company,
## compare them against a reference company, and generate a security/platform battle card.

requiredTools:
  - name: slack
    type: mcp

parameters:
  - name: referenceCompanyName
    schema:
      type: string
      description: "Name of the company that should be treated as the reference company in the report"
  - name: slackChannelId
    schema:
      type: string
      description: "Slack channel ID to crawl for competitor mentions"
  - name: lookBackDays
    schema:
      type: string
      default: "90"
      description: "How many days of Slack history to inspect for competitor mentions"
  - name: maxCompetitors
    schema:
      type: string
      default: "4"
      description: "Maximum number of competitors to research in depth"

transformers:
  - name: cleanup_slack_history
    onFunctionOutput: conversations_history
    jmesPath: 'structuredContent.messages || result.messages || messages'

components:
  schemas:
    company_profile:
      type: object
      required:
        - name
        - general_information
        - category
        - business_model
        - target_customer
        - moat
        - strengths
        - weaknesses
        - security_posture_summary
        - deployment_model
        - pricing_summary
      properties:
        name: { type: string, description: "Name of the company" }
        website_url: { type: string, description: "Official website URL" }
        general_information: { type: string, description: "Short overview of what the company does" }
        category: { type: string, description: "Primary market category or business type" }
        business_model:
          type: string
          enum: [b2b, b2c, b2b2c, marketplace, enterprise, smb, developer, hybrid, unknown]
        target_customer: { type: string, description: "Core buyer or customer segment" }
        moat: { type: string, description: "Potential competitive advantage or defensibility" }
        strengths:
          type: array
          items: { type: string }
        weaknesses:
          type: array
          items: { type: string }
        security_posture_summary:
          type: string
          description: "Plain-English summary of the company's visible security positioning"
        deployment_model:
          type: string
          description: "Hosted, hybrid, on-prem, self-hosted, or unknown"
        pricing_summary:
          type: string
          description: "Observable pricing or packaging posture"

    discovered_competitor:
      type: object
      required: [name]
      properties:
        name: { type: string }
        mention_context:
          type: array
          description: "Slack snippets or themes explaining why this company was mentioned"
          items: { type: string }
        mention_count:
          type: integer
          description: "Approximate number of mentions or repeated discussions in Slack"
        reason_relevant:
          type: string
          description: "Why this competitor matters to the reference company"

    security_control_row:
      type: object
      required: [control, category, reference_company_status, competitor_statuses]
      properties:
        control: { type: string, description: "Security control being compared" }
        category: { type: string, description: "Control family, for example Infrastructure Security or Access Control" }
        reference_company_status: { type: string, description: "Reference company status" }
        competitor_statuses:
          type: array
          items:
            type: object
            required: [competitor_name, status, evidence]
            properties:
              competitor_name: { type: string }
              status: { type: string, description: "confirmed, inferred, not-evidenced, or unknown" }
              evidence: { type: string, description: "Short source note or rationale" }

    platform_comparison_row:
      type: object
      required: [dimension, reference_company_position, competitor_positions]
      properties:
        dimension: { type: string, description: "Dimension being compared" }
        reference_company_position: { type: string, description: "How the reference company stands on this dimension" }
        competitor_positions:
          type: array
          items:
            type: object
            required: [competitor_name, position, advantage, notes]
            properties:
              competitor_name: { type: string }
              position: { type: string }
              advantage: { type: string, enum: [reference-company, competitor, neutral] }
              notes: { type: string }

    commercial_comparison_row:
      type: object
      required: [dimension, reference_company_position, competitor_positions]
      properties:
        dimension: { type: string, description: "Commercial or GTM comparison dimension" }
        reference_company_position: { type: string }
        competitor_positions:
          type: array
          items:
            type: object
            required: [competitor_name, position, advantage, notes]
            properties:
              competitor_name: { type: string }
              position: { type: string }
              advantage: { type: string, enum: [reference-company, competitor, neutral] }
              notes: { type: string }

    battle_card:
      type: object
      required: [executive_summary, how_to_win, win_themes, major_risks]
      properties:
        executive_summary: { type: string, description: "High-level summary of how the reference company stacks up" }
        how_to_win:
          type: array
          minItems: 3
          description: "Concrete recommendations for the reference company to win against the competitive set"
          items:
            type: object
            required: [move, rationale, target_segment, urgency]
            properties:
              move: { type: string }
              rationale: { type: string }
              target_segment: { type: string }
              urgency: { type: string, enum: [immediate, near-term, long-term] }
        win_themes:
          type: array
          items: { type: string }
        major_risks:
          type: array
          items: { type: string }


preCalls:
  - name: computeCutoff
    in: vars
    var: oldestTs
    args:
      days: "{{ .params.lookBackDays }}"
    code: |-
      const days = parseInt(args.days, 10);
      const safeDays = Number.isFinite(days) && days > 0 ? days : 90;
      const nowSec = Math.floor(Date.now() / 1000);
      nowSec - (safeDays * 86400);

  - name: conversations_history
    in: vars
    var: competitorSlackRaw
    args:
      channel: "{{ .params.slackChannelId }}"
      oldest: "{{ .vars.oldestTs }}"
      limit: 50

sessions:
  discover-competitors-from-slack:
    prompt: |-
      You are analyzing Slack history to discover competitors to {{ .params.referenceCompanyName }}.

      Here is the Slack history:
      ```json
      {{ json .vars.competitorSlackRaw }}
      ```

      {{ .params.referenceCompanyName }} is always the reference company.

      Identify competitor companies mentioned in Slack during this time window.
      Exclude {{ .params.referenceCompanyName }} itself.
      Merge duplicates, normalize company names, and only keep real competitors relevant to MCP,
      agent infrastructure, AI gateways, agent security, or adjacent platform alternatives.
      Return only the top {{ .params.maxCompetitors }} competitors by combined relevance and mention frequency.

      Map the output exactly to the competitors_from_slack schema.
      For each competitor include:
      - name
      - mention_context
      - mention_count
      - reason_relevant

  research-competitors:
    dependsOn:
      - session: discover-competitors-from-slack
    context: true
    iterateOn: context.competitors_from_slack
    prePrompt: |-
      Research {{ .it.name }} as a competitor to {{ .params.referenceCompanyName }}.
      Be concise and high-signal. Prefer official company pages, product docs, trust/security pages,
      and one or two highly relevant third-party sources if needed.
      Focus on:
      - company overview
      - product/platform scope
      - target customers
      - moat
      - visible strengths and weaknesses
      - deployment model
      - pricing posture
      - security positioning and public control evidence
    prompt: |-
      Return a company_profile object for {{ .it.name }}.
      Rules:
      - business_model must be one of: b2b, b2c, b2b2c, marketplace, enterprise, smb, developer, hybrid, unknown
      - strengths and weaknesses must be non-empty arrays when evidence exists, otherwise use 1-2 cautious items
      - do not leave business_model, deployment_model, pricing_summary, or security_posture_summary blank
      - if a fact is not clearly evidenced publicly, use "unknown" for enums and concise "Not clearly evidenced publicly." language for strings instead of inventing specifics
    tools:
      - type: internet_search

  synthesize-reference-company-profile:
    dependsOn:
      - session: discover-competitors-from-slack
    context: true
    prompt: |-
      Produce a company_profile object for {{ .params.referenceCompanyName }}.
      Use the official website, product pages, docs, and trust/security pages for {{ .params.referenceCompanyName }} if available.
      You may use the Slack-discovered competitor context to understand how {{ .params.referenceCompanyName }} is being compared in-market,
      but do not invent capabilities that are not clearly evidenced.

      Focus on {{ .params.referenceCompanyName }}'s actual positioning in MCP, AI agent infrastructure,
      security, governance, enterprise deployment, or adjacent product categories if those are relevant.

      Rules:
      - {{ .params.referenceCompanyName }} is the reference company in this report
      - prefer specific product positioning over generic boilerplate when the official positioning is directionally clear
      - business_model must be one of: b2b, b2c, b2b2c, marketplace, enterprise, smb, developer, hybrid, unknown
      - deployment_model, pricing_summary, and security_posture_summary must never be blank
      - if public evidence is limited, use "unknown" for enums and cautious, specific wording for strings instead of generic SaaS boilerplate
      - strengths and weaknesses should be grounded in observable product positioning and public claims
    tools:
      - type: internet_search

  build-competitive-report:
    dependsOn:
      - session: research-competitors
      - session: synthesize-reference-company-profile
    context: true
    prompt: |-
      Using the researched competitor profiles and reference company profile in context, produce the full
      competitive report in one pass to minimize runtime.

      Return all of the following fields exactly:
      - security_controls_matrix
      - platform_comparison_matrix
      - commercial_comparison_matrix
      - battle_card

      For security_controls_matrix:
      Include the highest-value controls customers actually care about in enterprise security reviews.
      Prioritize concise, decision-useful evidence over exhaustive coverage.
      Include control families such as:
      - infrastructure security
      - access control
      - secrets management
      - auditability
      - deployment isolation
      - customer data handling
      - change management
      - incident response

      For platform_comparison_matrix:
      Compare across product depth, deployment model, admin controls, observability, integration posture,
      security posture, buyer fit, and operational complexity.
      Every row must include one competitor_positions item for every researched competitor.
      Preserve a consistent competitor order across every row, matching competitors_from_slack.
      Every competitor_positions item must set advantage to exactly one of:
      - reference-company
      - competitor
      - neutral
      Do not leave advantage blank.

      For commercial_comparison_matrix:
      Focus on pricing posture, sales motion, implementation friction, enterprise readiness,
      and buyer objection profile.
      Every row must include one competitor_positions item for every researched competitor.
      Preserve a consistent competitor order across every row, matching competitors_from_slack.
      Every competitor_positions item must set advantage to exactly one of:
      - reference-company
      - competitor
      - neutral
      Do not leave advantage blank.

      For battle_card:
      Write from {{ .params.referenceCompanyName }}'s perspective and return:
      - executive_summary
      - how_to_win
      - win_themes
      - major_risks
      Additional rules:
      - every how_to_win item must set urgency to exactly one of: immediate, near-term, long-term
      - return at least 3 how_to_win items
      - major_risks should be specific to the current competitive set, not generic startup risks
      - executive_summary should explicitly describe where the reference company wins, where specialists beat it, and what must improve next
      Keep the recommendations concrete and suitable for product marketing, sales, or founder use.

      General comparison rules:
      - for the reference company, avoid repeating "Not clearly evidenced publicly." unless the field truly cannot be responsibly characterized
      - when public evidence is partial, prefer concise directional language such as "Enterprise-focused positioning with limited public detail on X"
      - choose an advantage value for every comparison item based on buyer perception in competitive deals, not just feature count

schema:
  type: object
  required:
    - competitors_from_slack
    - competitor_profiles
    - reference_company_profile
    - security_controls_matrix
    - platform_comparison_matrix
    - commercial_comparison_matrix
    - battle_card
  properties:
    competitors_from_slack:
      x-session: discover-competitors-from-slack
      type: array
      items:
        $ref: "#/components/schemas/discovered_competitor"

    competitor_profiles:
      x-session: research-competitors
      type: array
      items:
        $ref: "#/components/schemas/company_profile"

    reference_company_profile:
      x-session: synthesize-reference-company-profile
      $ref: "#/components/schemas/company_profile"

    security_controls_matrix:
      x-session: build-competitive-report
      type: array
      items:
        $ref: "#/components/schemas/security_control_row"

    platform_comparison_matrix:
      x-session: build-competitive-report
      type: array
      items:
        $ref: "#/components/schemas/platform_comparison_row"

    commercial_comparison_matrix:
      x-session: build-competitive-report
      type: array
      items:
        $ref: "#/components/schemas/commercial_comparison_row"

    battle_card:
      x-session: build-competitive-report
      $ref: "#/components/schemas/battle_card"