fullstackgtm 0.31.0 → 0.33.0

package/CHANGELOG.md

@@ -5,6 +5,60 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 The path to 1.0 is planned in [docs/roadmap-to-1.0.md](./docs/roadmap-to-1.0.md).
 
+## [0.33.0] — 2026-06-18
+
+### Added
+
+- **Market sourcing helpers (`marketSourcing.ts`)** — find the right page to
+  capture per vendor, detect acquired/redirected vendors, and extract brand logos,
+  with zero coupling to any transport:
+  - `pickCategoryPage(html, baseUrl, keywords)` — follow a vendor's own nav to its
+    category page (so multi-product companies like SAP/Salesforce are captured on
+    the product page, not the corporate homepage). Pure.
+  - `findCategoryPageInSitemap(rootUrl, keywords, fetchText?)` — sitemap fallback
+    for JS-mega-menu sites whose product links aren't in the rendered homepage.
+  - `findCategoryPage(...)` — nav-scan then sitemap, combined.
+  - `detectDrift(url, srcHost, resolve?)` / `resolveFinalUrl(url)` — skip vendors
+    whose site redirects to a different company (an acquired/defunct product).
+  - `extractLogoUrl(html, baseUrl)` + `fetchLogoDataUri(homepageUrl, html?, …)` —
+    a vendor logo as a self-contained `data:` URI for `MarketVendor.logo`.
+  - `categoryKeywords()` + `registrableDomain()` utilities.
+
+  Pure functions operate on already-fetched HTML; fetching helpers default to the
+  package's SSRF-guarded `assertPublicUrl` + `fetch` but accept an injectable
+  fetcher (testable offline, browser-render-friendly). 8 tests.
+
+## [0.32.0] — 2026-06-18
+
+### Added
+
+- **Brand logos plot inside the market-map scatter bubbles.** When a vendor has
+  a `data:image/…` logo and its dot is big enough to read it (r ≥ 12), the logo
+  becomes the in-bubble label: a white disc clipped to the circle carries the
+  logo, a colored rim still ties the dot to its legend color, and the legend
+  number moves just above so the cross-reference holds. Smaller or logo-less
+  dots keep the numbered-bubble treatment. Same `img-src data:` safety as the
+  legend/header logos — only `data:` URIs are honored; anything else is refused
+  and never emitted as an `<image>`. Render stays byte-deterministic.
+
+- **Call-type classification + type-specific coaching rubrics.** New `call
+  classify` verb runs a deterministic, key-free signal classifier over a
+  transcript (12 call types: prospecting, discovery, demo, technical_validation,
+  negotiation, closing, onboarding, check_in, renewal_expansion, qbr, internal,
+  other), returning the type with a confidence and a written reason; `--llm`
+  adds a model tiebreak for the ambiguous middle, `--list` prints the taxonomy.
+  `call score` now **auto-selects the type-specific rubric** from that
+  classification instead of applying one generic discovery rubric to every call
+  — override with `--call-type <type>` or `--rubric`. The `Rubric` type gains
+  optional `name`, `callType`, `bands`, and per-dimension `anchorsHigh` /
+  `anchorsLow` / `evidenceCues` / `coachingPrompts`; anchored examples are
+  threaded into the scoring prompt (cuts variance) and the weighted overall is
+  mapped to a qualitative band, all computed client-side. Ten built-in presets
+  (`call score --list-rubrics`). New exports: `classifyCall`, `classifyCallLlm`,
+  `rubricForCallType`, `rubricPresets`, `bandForScore`, `CALL_TYPES`,
+  `CALL_TYPE_IDS`, `BANDS_5`, and the `CallType` / `CallTypeDef` /
+  `CallClassification` / `RubricDimension` / `ScoreBand` types.
+
 ## [0.31.0] — 2026-06-18
 
 ### Added

package/README.md

@@ -59,14 +59,18 @@ Calls are where pipeline truth lives. `call parse` normalizes any transcript dia
 
 **Extraction is LLM-powered by default, with your own key.** The first time you run `call parse` or `call score`, the CLI asks for an Anthropic or OpenAI API key (auto-detected from the prefix), validates it against the provider, and stores it in the 0600 credential store — same treatment as CRM logins. Or skip the prompt: set `ANTHROPIC_API_KEY`/`OPENAI_API_KEY`, or `echo "$KEY" | fullstackgtm login anthropic` (or `openai`). The key talks directly to your provider — raw fetch, no SDK, no middleman. `--model` overrides the defaults (claude-haiku-4-5 / gpt-4o-mini). LLM insights carry verbatim-quote evidence and, for next steps, owner/deadline/commitment. Pass `--deterministic` for the free, instant, byte-stable keyword baseline (no key needed — right for CI and warehouse bulk loads). Every insight is provenance-marked (`extractor: "llm:anthropic:…"` vs `"deterministic"`).
 
-**`call score`** rates the call against a coaching rubric — five built-in dimensions (discovery, next steps, stakeholders, value, objections) or your own via `--rubric rubric.json` (`{ scale, dimensions: [{ name, weight, rubric }] }`); the weighted overall is computed deterministically client-side, every dimension score is evidence-quoted, and the rubric file is where your client-specific coaching framework lives.
+**`call classify`** picks the call type before scoring, because a renewal scored on "Depth of Discovery" is just wrong. It runs a **deterministic, key-free** signal classifier over the transcript — 12 call types (prospecting, discovery, demo, technical_validation, negotiation, closing, onboarding, check_in, renewal_expansion, qbr, internal, other) — returning the type with a confidence and a written reason; pass `--llm` for a model tiebreak on the ambiguous middle. It needs no API key, so it runs free in CI and on warehouse bulk loads (`--list` prints the taxonomy).
+
+**`call score`** rates the call against a coaching rubric. By default it **auto-selects the type-specific rubric** from the classification — each call type ships its own dimensions with anchored high/low examples and evidence cues (cuts scoring variance). Override with `--call-type <type>` to force a preset, or `--rubric rubric.json` for your own (`{ scale, name?, callType?, bands?, dimensions: [{ name, weight, rubric, anchorsHigh?, anchorsLow?, evidenceCues?, coachingPrompts? }] }`). The weighted overall is computed deterministically client-side, mapped to a qualitative band, every dimension score is evidence-quoted, and the rubric file is where your client-specific coaching framework lives (`--list-rubrics` prints the built-in presets).
 
 `call link` answers "which deal was this call about" from attendee domains (account domain or contact emails → open deals, most recent activity first, with confidence + reason). `call plan` turns next-step insights into the same governed plan lifecycle as everything else.
 
 ```bash
-# Coaching pipeline (Slack + CRM): parse → score → link → govern the writeback
+# Coaching pipeline (Slack + CRM): parse → classify → score → link → govern the writeback
 fullstackgtm call parse --transcript call.txt --title "Acme disco" --out parsed.json   # LLM extraction
-fullstackgtm call score --call parsed.json --rubric team-rubric.json                   # evidence-quoted scorecard
+fullstackgtm call classify --call parsed.json                                          # deterministic call type
+fullstackgtm call score --call parsed.json                                            # auto-selects the type's rubric
+fullstackgtm call score --call parsed.json --rubric team-rubric.json                   # …or bring your own framework
 fullstackgtm call link --attendees jane@acme.com --provider hubspot                    # → deal id + reason
 fullstackgtm call plan --call parsed.json --deal 123 --provider hubspot --save
 # review → plans approve → apply: deal.next_step + follow-up tasks, compare-and-set protected

package/dist/callTypes.d.ts

@@ -0,0 +1,72 @@
+import type { Rubric, ScoreBand } from "./llm.ts";
+/**
+ * Call-type taxonomy, a deterministic signal-based classifier, and one
+ * type-specific coaching rubric per call type.
+ *
+ * The design mirrors the rest of the package: deterministic by default,
+ * explainable, and byte-stable. `classifyCall` reads a transcript and returns
+ * a ranked classification with a written reason — no LLM, no key, no network —
+ * so it runs free in CI and on warehouse bulk loads. The LLM tiebreak
+ * (`classifyCallLlm` in llm.ts) is opt-in, for the ambiguous middle.
+ *
+ * Scoring a renewal against a discovery rubric is simply wrong, so each call
+ * type carries its own rubric: the dimensions that matter for *that*
+ * conversation, with anchored high/low examples and evidence cues that sharpen
+ * the verbatim-quote grounding the scorer already requires.
+ */
+export type CallType = "prospecting" | "discovery" | "demo" | "technical_validation" | "negotiation" | "closing" | "onboarding" | "check_in" | "renewal_expansion" | "qbr" | "internal" | "other";
+export declare const CALL_TYPE_IDS: CallType[];
+export type CallTypeDef = {
+    id: CallType;
+    name: string;
+    phase: "pre_sale" | "post_sale" | "neither";
+    definition: string;
+    /** Phrases that, when present, argue *for* this type (lowercased, substring match). */
+    signals: string[];
+    /** Phrases that argue *against* this type even if a signal matched. */
+    negativeSignals?: string[];
+    /** Types this is commonly confused with — surfaced in the classifier reason. */
+    confusedWith?: CallType[];
+};
+/**
+ * Our own taxonomy. Signals are authored phrases, not lifted from any third
+ * party; they are intentionally conservative (high-precision verbs and nouns
+ * that rarely appear off-topic) so the deterministic pass is trustworthy and
+ * the ambiguous remainder is handed to the LLM tiebreak rather than guessed.
+ */
+export declare const CALL_TYPES: CallTypeDef[];
+export type CallClassification = {
+    type: CallType;
+    confidence: "high" | "low" | "none";
+    reason: string;
+    /** All types that matched at least one signal, strongest first. */
+    candidates: Array<{
+        type: CallType;
+        score: number;
+        matched: string[];
+    }>;
+    method: "deterministic";
+};
+/**
+ * Classify a call from its transcript using authored phrase signals. Pure,
+ * deterministic, key-free. Score = distinct positive signals matched minus
+ * distinct negative signals; the strongest type wins. Confidence is `high`
+ * only when one type clearly leads (>=2 signals and a >=2 margin over the
+ * runner-up); a single weak signal yields `low`; no signal yields `other`/none.
+ */
+export declare function classifyCall(transcript: string): CallClassification;
+/** Shared qualitative bands over a 1-5 weighted overall. */
+export declare const BANDS_5: ScoreBand[];
+/**
+ * Pick the qualitative band for a weighted overall: the highest band whose
+ * `min` the score reaches. Deterministic, client-side — same input, same band.
+ */
+export declare function bandForScore(score: number, bands: ScoreBand[]): ScoreBand | undefined;
+/**
+ * The type-specific rubric for a call type, or the generic fallback. The
+ * generic rubric is intentionally discovery-leaning (the most common scored
+ * call) and is what `other`/`internal`/unknown resolve to.
+ */
+export declare function rubricForCallType(type: CallType, fallback: Rubric): Rubric;
+/** All authored presets, for `--list` and docs. */
+export declare function rubricPresets(): Rubric[];