Analysis Service

import { runAnalysis } from "@oneglanse/services";
import type { AnalysisInputSingle, BrandAnalysisResult } from "@oneglanse/types";

const result: BrandAnalysisResult = await runAnalysis({
  brandName: "HubSpot",
  brandDomain: "hubspot.com",
  prompt: "What are the best CRM tools for small businesses?",
  response: "For small businesses, HubSpot offers excellent value..." // AI response
});

console.log(`GEO Score: ${result.geoScore.overall}/100`);
console.log(`Visibility: ${result.presence.visibility}`);
console.log(`Sentiment: ${result.sentiment.score}`);
console.log(`Rank: #${result.position.rankPosition} of ${result.position.totalRanked}`);

import { analysePromptsForWorkspace } from "@oneglanse/services";

const result = await analysePromptsForWorkspace({
  workspaceId: "workspace_abc123",
  batchSize: 50,        // Optional: responses per batch
  analyzeAll: true      // Optional: process all or just first batch
});

console.log(`Analyzed: ${result.analysedCount}`);
console.log(`Failed: ${result.failedCount}`);
console.log(`Remaining: ${result.remainingCount}`);

if (result.errors.length > 0) {
  console.log("Errors:");
  result.errors.forEach(e => {
    console.log(`  ${e.modelProvider}: ${e.error}`);
  });
}

import { fetchAnalysedPrompts } from "@oneglanse/services";

const records = await fetchAnalysedPrompts({
  workspaceId: "workspace_abc123",
  limit: 10000  // Optional, defaults to 10,000
});

records.forEach(record => {
  console.log(`Prompt: ${record.prompt}`);
  console.log(`Provider: ${record.model_provider}`);
  
  if (record.brand_analysis) {
    const analysis = record.brand_analysis;
    console.log(`  GEO Score: ${analysis.geoScore.overall}`);
    console.log(`  Visibility: ${analysis.presence.visibility}`);
    console.log(`  Sentiment: ${analysis.sentiment.score}`);
  } else {
    console.log(`  (Not yet analyzed)`);
  }
});

import { getLastPromptRunTime } from "@oneglanse/services";

const lastRun = await getLastPromptRunTime({
  workspaceId: "workspace_abc123"
});

if (lastRun) {
  console.log(`Last run: ${new Date(lastRun).toLocaleString()}`);
} else {
  console.log("No prompts have been run yet");
}

import { resetWorkspaceAnalysis } from "@oneglanse/services";

await resetWorkspaceAnalysis({
  workspaceId: "workspace_abc123"
});

console.log("Analysis reset - responses will be re-analyzed on next run");

visibility = round(
  (A × 0.25) + (B × 0.25) + (C × 0.20) + (D × 0.15) + (E × 0.15)
)

overall = round(
  (visibility × 0.25) +
  (rankValue × 0.25) +      // #1→100, #2→80, #3→65, #4→50...
  (sentiment × 0.25) +
  (recommendationValue × 0.25)  // top_pick→100, strong_alternative→80...
)

Best for Small Teams:
  1. HubSpot      → Absolute rank: 1
  2. Pipedrive    → Absolute rank: 2
  3. Freshsales   → Absolute rank: 3

Best for Enterprise:
  1. Salesforce   → Absolute rank: 4 (not 1!)
  2. Dynamics     → Absolute rank: 5

import { 
  analysePromptsForWorkspace,
  fetchAnalysedPrompts 
} from "@oneglanse/services";
import { authorizedWorkspaceProcedure } from "../../procedures";
import { z } from "zod";

export const analysisRouter = createTRPCRouter({
  analyzeMetrics: authorizedWorkspaceProcedure
    .input(z.object({
      analyzeAll: z.boolean().optional().default(true)
    }))
    .mutation(async ({ ctx, input }) => {
      return analysePromptsForWorkspace({
        workspaceId: ctx.workspaceId,
        analyzeAll: input.analyzeAll ?? true,
      });
    }),

  fetchAnalysis: authorizedWorkspaceProcedure.query(async ({ ctx }) => {
    return fetchAnalysedPrompts({ 
      workspaceId: ctx.workspaceId 
    });
  }),
});

CREATE TABLE analytics.prompt_analysis (
  id String,
  prompt_id String,
  workspace_id String,
  prompt String,
  user_id String,
  model_provider String,
  brand_analysis String,  -- JSON serialized BrandAnalysisResult
  prompt_run_at DateTime,
  created_at DateTime DEFAULT now()
) ENGINE = MergeTree()
ORDER BY (workspace_id, prompt_run_at, model_provider);

import type {
  AnalysisInputSingle,
  BrandAnalysisResult,
  PromptAnalysis,
  AnalysisRecord,
} from "@oneglanse/types";

interface BrandAnalysisResult {
  geoScore: {
    overall: number;        // 0-100
    verdict: string;
  };
  presence: {
    mentioned: boolean;
    mentionCount: number;
    visibility: number;     // 0-100
    prominence: "dominant" | "significant" | "moderate" | "minor" | "passing" | "absent";
    firstMentionPosition: "top" | "middle" | "bottom" | "absent";
  };
  position: {
    rankPosition: number | null;
    totalRanked: number | null;
    isTopPick: boolean;
    isTopThree: boolean;
    rankingContext: string | null;
  };
  sentiment: {
    score: number;          // 0-100
    label: "very_negative" | "negative" | "neutral" | "positive" | "very_positive";
    positives: string[];
    negatives: string[];
  };
  recommendation: {
    type: "top_pick" | "strong_alternative" | "conditional" | "mentioned_only" | "discouraged" | "not_mentioned";
    bestFor: string[];
    caveats: string[];
  };
  competitors: Array<{
    name: string;
    domain: string | null;
    visibility: number;
    sentiment: number;
    rankPosition: number | null;
    isRecommended: boolean;
    winsOver: string[];
    losesTo: string[];
  }>;
  perception: {
    coreClaims: string[];
    differentiators: string[];
    bestKnownFor: string | null;
    pricingPerception: "premium" | "mid_range" | "budget" | "free" | "not_mentioned";
  };
  risks: {
    hasRisks: boolean;
    items: Array<{
      type: "outdated_info" | "factual_error" | "brand_confusion" | "negative_association" | "missing_from_response";
      severity: "critical" | "warning" | "info";
      detail: string;
    }>;
  };
  actions: Array<{
    priority: "critical" | "high" | "medium" | "low";
    recommendation: string;
  }>;
  metadata?: {
    brandName: string;
    brandDomain: string;
    prompt: string;
    prompt_id: string | null;
    analyzedAt: string;
  };
}