@vellumai/assistant 0.4.48 → 0.4.50

package/src/memory/conflict-intent.ts

@@ -1,205 +0,0 @@
-/**
- * Shared conflict intent helpers used by both interactive conflict gating and
- * background conflict resolution jobs.
- */
-
-export interface ConflictStatementPair {
-  existingStatement: string;
-  candidateStatement: string;
-}
-
-export function computeConflictRelevance(
-  userMessage: string,
-  conflict: ConflictStatementPair,
-): number {
-  const queryTokens = tokenizeForConflictRelevance(userMessage);
-  if (queryTokens.size === 0) return 0;
-  const existingTokens = tokenizeForConflictRelevance(
-    conflict.existingStatement,
-  );
-  const candidateTokens = tokenizeForConflictRelevance(
-    conflict.candidateStatement,
-  );
-  return Math.max(
-    overlapRatio(queryTokens, existingTokens),
-    overlapRatio(queryTokens, candidateTokens),
-  );
-}
-
-const NOISE_TOKENS = new Set([
-  "http",
-  "https",
-  "github",
-  "gitlab",
-  "www",
-  "com",
-  "org",
-]);
-
-// Matches full URLs (http(s)://...) and scheme-less bare domain URLs for known
-// code hosting sites (e.g. github.com/org/repo/pull/123) so embedded path
-// segments like "pull", "issue", "ticket" don't leak into relevance scoring.
-// The scheme-less branch is restricted to known hosting domains to avoid
-// stripping dotted identifiers like "index.ts/runtime".
-const URL_PATTERN =
-  /https?:\/\/[^\s)>\]]+|(?:github|gitlab|bitbucket)\.(?:com|org|io)\/[^\s)>\]]*/gi;
-
-export function tokenizeForConflictRelevance(input: string): Set<string> {
-  const stripped = input.replace(URL_PATTERN, " ");
-  const tokens = stripped
-    .toLowerCase()
-    .split(/[^a-z0-9]+/g)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 4)
-    .filter((token) => !/^\d+$/.test(token))
-    .filter((token) => !NOISE_TOKENS.has(token));
-  return new Set(tokens);
-}
-
-export function overlapRatio(left: Set<string>, right: Set<string>): number {
-  if (left.size === 0 || right.size === 0) return 0;
-  let overlap = 0;
-  for (const token of left) {
-    if (right.has(token)) overlap += 1;
-  }
-  return overlap / Math.max(left.size, right.size);
-}
-
-/**
- * Tokenize for statement-to-statement coherence checking.
- * Uses a lower minimum token length (>= 3) than `tokenizeForConflictRelevance`
- * to preserve short technical terms like "vim", "css", "git", "npm", etc.
- */
-function tokenizeForCoherence(input: string): Set<string> {
-  const stripped = input.replace(URL_PATTERN, " ");
-  const tokens = stripped
-    .toLowerCase()
-    .split(/[^a-z0-9]+/g)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 3)
-    .filter((token) => !/^\d+$/.test(token))
-    .filter((token) => !NOISE_TOKENS.has(token));
-  return new Set(tokens);
-}
-
-/**
- * Check whether two conflict statements have topical coherence.
- * Returns true if the statements share at least one meaningful token.
- * Uses a permissive tokenizer (>= 3 chars) to avoid dropping short
- * technical terms like "vim", "css", "git", etc.
- */
-export function areStatementsCoherent(
-  statementA: string,
-  statementB: string,
-): boolean {
-  const tokensA = tokenizeForCoherence(statementA);
-  const tokensB = tokenizeForCoherence(statementB);
-  return overlapRatio(tokensA, tokensB) > 0;
-}
-
-// Action verbs that signal the user is making a deliberate choice.
-const ACTION_CUES = new Set([
-  "keep",
-  "use",
-  "prefer",
-  "go",
-  "pick",
-  "choose",
-  "take",
-  "want",
-  "select",
-]);
-
-// Directional/merge cue words mirrored from clarification-resolver.ts heuristics.
-const DIRECTIONAL_CUES = new Set([
-  "existing",
-  "old",
-  "previous",
-  "first",
-  "earlier",
-  "original",
-  "candidate",
-  "new",
-  "latest",
-  "second",
-  "updated",
-  "instead",
-  "replace",
-  "both",
-  "merge",
-  "combine",
-  "together",
-  "either",
-  "mix",
-  "option",
-  "former",
-  "latter",
-]);
-
-const MAX_REPLY_WORD_COUNT = 12;
-
-// Direction-only matches (no action verb) must be very short to avoid
-// false positives from unrelated statements that happen to contain
-// common words like "new", "old", "option", etc.
-const MAX_DIRECTION_ONLY_WORD_COUNT = 4;
-
-// Messages starting with a question word are unlikely to be clarification
-// replies even when they lack a trailing question mark.
-const QUESTION_WORD_PREFIXES = new Set([
-  "what",
-  "how",
-  "why",
-  "where",
-  "when",
-  "which",
-  "who",
-  "whom",
-  "whose",
-]);
-
-/**
- * Determines whether a user message looks like a deliberate clarification
- * reply (e.g. "keep the new one", "both", "option B").
- */
-export function looksLikeClarificationReply(userMessage: string): boolean {
-  const trimmed = userMessage.trim();
-  if (trimmed.endsWith("?")) return false;
-
-  const words = trimmed.toLowerCase().split(/\s+/).filter(Boolean);
-  if (words.length === 0 || words.length > MAX_REPLY_WORD_COUNT) return false;
-
-  const normalized = words.map((w) => w.replace(/[^a-z]/g, ""));
-
-  // Reject messages that start with a question word (even without '?').
-  // Match exact question words or contractions (e.g. "what's", "where's"),
-  // but not words that merely share a prefix (e.g. "whichever", "however").
-  const firstWord = words[0];
-  const firstNorm = normalized[0];
-  for (const qw of QUESTION_WORD_PREFIXES) {
-    if (
-      firstNorm === qw ||
-      (firstWord.startsWith(qw) &&
-        "'\u2018\u2019".includes(firstWord[qw.length]))
-    )
-      return false;
-  }
-
-  const hasAction = normalized.some((w) => ACTION_CUES.has(w));
-  const hasDirection = normalized.some((w) => DIRECTIONAL_CUES.has(w));
-
-  if (hasAction) return true;
-  if (hasDirection) return words.length <= MAX_DIRECTION_ONLY_WORD_COUNT;
-  return false;
-}
-
-/**
- * Conflict resolution requires explicit clarification intent with non-zero
- * topical overlap with the conflict statements.
- */
-export function shouldAttemptConflictResolution(input: {
-  clarificationReply: boolean;
-  relevance: number;
-}): boolean {
-  if (!input.clarificationReply) return false;
-  return input.relevance > 0;
-}

package/src/memory/conflict-policy.ts

@@ -1,127 +0,0 @@
-/**
- * Pure, deterministic policy helpers for memory conflict eligibility.
- * Used by contradiction checker, session conflict gate, and background resolver.
- */
-
-export interface ConflictPolicyConfig {
-  conflictableKinds: readonly string[];
-  [key: string]: unknown;
-}
-
-/**
- * Returns true when the given memory item kind is eligible to participate
- * in conflict detection according to the current policy.
- */
-export function isConflictKindEligible(
-  kind: string,
-  config: ConflictPolicyConfig,
-): boolean {
-  return config.conflictableKinds.includes(kind);
-}
-
-/**
- * Returns true when both sides of a potential conflict pair are kind-eligible.
- */
-export function isConflictKindPairEligible(
-  existingKind: string,
-  candidateKind: string,
-  config: ConflictPolicyConfig,
-): boolean {
-  return (
-    isConflictKindEligible(existingKind, config) &&
-    isConflictKindEligible(candidateKind, config)
-  );
-}
-
-// ── Transient statement classification ─────────────────────────────────
-
-const PR_URL_PATTERN = /github\.com\/[^/]+\/[^/]+\/pull\/\d+/i;
-const ISSUE_TICKET_PATTERN = /\b(?:issue|pr|ticket|pull request)\s*#?\d+/i;
-const TRACKING_LANGUAGE_PATTERN =
-  /\b(?:this pr|that issue|while we wait|currently tracking)\b/i;
-
-// Statements about needing clarification are transient conversational artifacts
-// extracted from previous conflict-gate interactions — not durable facts.
-// Allowing them into the conflict pipeline creates self-reinforcing loops.
-// Patterns are kept narrow to avoid filtering legitimate durable instructions.
-const META_CLARIFICATION_PATTERN =
-  /\b(?:needs? clarification\b|unclear which (?:version|value|setting)\b|user should (?:specify|clarify)\b|conflicting (?:notes|instructions)(?:\s*[:."]|\s+(?:about|regarding|for)\b))/i;
-
-/**
- * Returns true when a statement looks like a transient tracking note
- * (PR URLs, issue references, short-lived progress notes) rather than
- * a durable user preference or instruction.
- */
-export function isTransientTrackingStatement(statement: string): boolean {
-  if (PR_URL_PATTERN.test(statement)) return true;
-  if (ISSUE_TICKET_PATTERN.test(statement)) return true;
-  if (TRACKING_LANGUAGE_PATTERN.test(statement)) return true;
-  if (META_CLARIFICATION_PATTERN.test(statement)) return true;
-  return false;
-}
-
-const DURABLE_INSTRUCTION_CUES =
-  /\b(?:always|never|default|every time|by default|style|format|tone|convention|standard)\b/i;
-
-/**
- * Returns true when a statement contains strong durable instruction cues,
- * suggesting it represents a persistent user preference or style rule.
- */
-export function isDurableInstructionStatement(statement: string): boolean {
-  return DURABLE_INSTRUCTION_CUES.test(statement);
-}
-
-// ── Verification-state provenance ──────────────────────────────────────
-
-// States indicating user involvement — either the user directly stated
-// the information, explicitly confirmed it, or it was bulk-imported from
-// a trusted external source the user chose to connect.
-const USER_EVIDENCED_STATES = new Set([
-  "user_reported",
-  "user_confirmed",
-  "legacy_import",
-]);
-
-/**
- * Returns true when the verification state indicates user provenance
- * (as opposed to purely assistant-inferred).
- */
-export function isUserEvidencedVerificationState(state: string): boolean {
-  return USER_EVIDENCED_STATES.has(state);
-}
-
-/**
- * Returns true when at least one side of a conflict pair has user-evidenced
- * provenance. Assistant-inferred-only conflicts should not escalate into
- * user-facing behavior.
- */
-export function isConflictUserEvidenced(
-  existingState: string,
-  candidateState: string,
-): boolean {
-  return (
-    isUserEvidencedVerificationState(existingState) ||
-    isUserEvidencedVerificationState(candidateState)
-  );
-}
-
-/**
- * Returns true when a statement of the given kind is eligible to participate
- * in conflict detection at the statement level. This combines kind eligibility
- * with statement-level durability heuristics.
- *
- * For instruction/style kinds: requires positive durable cues and no transient cues.
- * For other eligible kinds: rejects if transient tracking cues dominate.
- */
-export function isStatementConflictEligible(
-  kind: string,
-  statement: string,
-  config?: ConflictPolicyConfig,
-): boolean {
-  if (config && !isConflictKindEligible(kind, config)) return false;
-  if (isTransientTrackingStatement(statement)) return false;
-  if (kind === "instruction" || kind === "style") {
-    return isDurableInstructionStatement(statement);
-  }
-  return true;
-}