teleportation-cli 1.4.0 → 1.4.1

package/lib/intelligence/transcript-mine.js

@@ -0,0 +1,339 @@
+/**
+ * Transcript request-pattern mining.
+ *
+ * Mines repeated request intents from normalized transcript events so
+ * routing/guidance systems can learn common user asks.
+ */
+
+const DEFAULT_MIN_OCCURRENCES = 2;
+const DEFAULT_TOP_K = 25;
+const MAX_REQUEST_TEXT_LENGTH = 1000;
+const MIN_TOKENS_PER_PATTERN = 3;
+
+const STOP_WORDS = new Set([
+  'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how', 'i',
+  'in', 'is', 'it', 'me', 'my', 'of', 'on', 'or', 'our', 'please', 'that',
+  'the', 'this', 'to', 'us', 'we', 'what', 'when', 'where', 'which', 'with',
+  'you', 'your',
+]);
+
+const TOKEN_ALIASES = new Map([
+  ['vs', 'versus'],
+  ['v', 'versus'],
+]);
+
+const NOISE_PREFIXES = [
+  '[request interrupted by user',
+  '[request interrupted by user for tool use',
+  '[image:',
+  '<local-command-caveat>',
+  'this session is being continued from a previous conversation',
+  'base directory for this skill:',
+];
+
+const NOISE_SUBSTRINGS = [
+  'please continue the conversation from where we left off',
+  'if you need specific details from before compaction',
+  'source: /users/',
+  'original 3024x1600',
+];
+
+const NOISE_EXACT = new Set([
+  'yes',
+  'yes proceed',
+  'proceed',
+  'continue',
+  'go',
+  'ok proceed',
+  'okay proceed',
+  'lets merge',
+  'let us merge',
+]);
+
+function isLikelyNoiseText(text) {
+  if (typeof text !== 'string') return true;
+  const normalized = text.trim().toLowerCase();
+  if (!normalized) return true;
+
+  const compact = normalized.replace(/\s+/g, ' ').trim();
+
+  if (compact.length > MAX_REQUEST_TEXT_LENGTH) return true;
+  if (NOISE_EXACT.has(compact)) return true;
+  if (NOISE_PREFIXES.some((prefix) => compact.startsWith(prefix))) return true;
+  if (NOISE_SUBSTRINGS.some((fragment) => compact.includes(fragment))) return true;
+  return false;
+}
+
+function toStem(token) {
+  if (token.endsWith('ing') && token.length > 5) return token.slice(0, -3);
+  if (token.endsWith('ed') && token.length > 4) return token.slice(0, -2);
+  if (token.endsWith('es') && token.length > 4) return token.slice(0, -2);
+  if (token.endsWith('s') && token.length > 3) return token.slice(0, -1);
+  return token;
+}
+
+function tokenize(text) {
+  if (typeof text !== 'string') return [];
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter(Boolean)
+    .map((token) => TOKEN_ALIASES.get(token) || token)
+    .map(toStem)
+    .filter((token) => token.length >= 3 && !STOP_WORDS.has(token));
+}
+
+function extractRequestText(event) {
+  if (!event || typeof event !== 'object') return null;
+  const metadata = event.metadata || {};
+
+  const fields = [
+    metadata.user_prompt,
+    metadata.user_message,
+    metadata.prompt,
+    metadata.instruction,
+    metadata.query,
+    metadata.task_prompt,
+  ];
+
+  for (const value of fields) {
+    if (typeof value !== 'string') continue;
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    if (isLikelyNoiseText(trimmed)) continue;
+    return trimmed;
+  }
+
+  return null;
+}
+
+function classifyIntent(tokens) {
+  const set = new Set(tokens);
+
+  if (set.has('skill') || set.has('workflow') || set.has('agent') || set.has('claude')) {
+    return 'skill-orchestration';
+  }
+  if (set.has('benchmark') || set.has('cost') || set.has('latency') || set.has('quality')) {
+    return 'benchmark-analysis';
+  }
+  if (set.has('route') || set.has('model') || set.has('harness') || set.has('codex') || set.has('gemini')) {
+    return 'routing-selection';
+  }
+  if (set.has('approval') || set.has('approve') || set.has('deny') || set.has('escalate') || set.has('risk')) {
+    return 'approval-policy';
+  }
+  if (set.has('fix') || set.has('error') || set.has('fail') || set.has('test') || set.has('bug')) {
+    return 'debugging';
+  }
+
+  return 'general-request';
+}
+
+function buildSignature(tokens) {
+  const unique = [];
+  const seen = new Set();
+
+  for (const token of tokens) {
+    if (seen.has(token)) continue;
+    seen.add(token);
+    unique.push(token);
+    if (unique.length >= 6) break;
+  }
+
+  return unique.join(' ');
+}
+
+function incrementCount(map, key) {
+  map.set(key, (map.get(key) || 0) + 1);
+}
+
+export function mineRequestPatterns(events, options = {}) {
+  if (!Array.isArray(events) || events.length === 0) return [];
+
+  const minOccurrences = Number.isInteger(options.minOccurrences)
+    ? Math.max(1, options.minOccurrences)
+    : DEFAULT_MIN_OCCURRENCES;
+  const topK = Number.isInteger(options.topK) ? Math.max(1, options.topK) : DEFAULT_TOP_K;
+
+  const buckets = new Map();
+
+  for (const event of events) {
+    const text = extractRequestText(event);
+    if (!text) continue;
+
+    const tokens = tokenize(text);
+    if (tokens.length < MIN_TOKENS_PER_PATTERN) continue;
+
+    const signature = buildSignature(tokens);
+    if (!signature) continue;
+
+    const existing = buckets.get(signature) || {
+      signature,
+      frequency: 0,
+      sample_text: text,
+      intents: new Map(),
+      task_categories: new Map(),
+      providers: new Map(),
+    };
+
+    existing.frequency += 1;
+    incrementCount(existing.intents, classifyIntent(tokens));
+    incrementCount(existing.task_categories, event.task_category || 'unknown');
+    if (event.provider) incrementCount(existing.providers, event.provider);
+
+    buckets.set(signature, existing);
+  }
+
+  const totalMatched = Array.from(buckets.values()).reduce((sum, bucket) => sum + bucket.frequency, 0);
+  if (totalMatched === 0) return [];
+
+  return Array.from(buckets.values())
+    .filter((bucket) => bucket.frequency >= minOccurrences)
+    .map((bucket) => {
+      const dominantIntent = Array.from(bucket.intents.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] || 'general-request';
+      const confidence = Number((bucket.frequency / totalMatched).toFixed(4));
+
+      return {
+        signature: bucket.signature,
+        frequency: bucket.frequency,
+        confidence,
+        dominant_intent: dominantIntent,
+        sample_text: bucket.sample_text,
+        task_categories: Object.fromEntries(bucket.task_categories),
+        providers: Object.fromEntries(bucket.providers),
+      };
+    })
+    .sort((a, b) => {
+      if (b.frequency !== a.frequency) return b.frequency - a.frequency;
+      return a.signature.localeCompare(b.signature);
+    })
+    .slice(0, topK);
+}
+
+// ---------------------------------------------------------------------------
+// Cost estimation
+// ---------------------------------------------------------------------------
+
+const MODEL_PRICES = {
+  'claude-sonnet': { input: 3.00, output: 15.00 },
+  'claude-opus':   { input: 15.00, output: 75.00 },
+  'gemini-2.5-pro': { input: 1.25, output: 10.00 },
+  'o3':            { input: 10.00, output: 40.00 },
+  'o4-mini':       { input: 1.10, output: 4.40 },
+  'default':       { input: 3.00, output: 15.00 },
+};
+
+function getModelPrice(modelName) {
+  if (typeof modelName !== 'string') return MODEL_PRICES['default'];
+  const lower = modelName.toLowerCase();
+  for (const key of Object.keys(MODEL_PRICES)) {
+    if (key === 'default') continue;
+    if (lower.startsWith(key)) return MODEL_PRICES[key];
+  }
+  return MODEL_PRICES['default'];
+}
+
+function computeSessionCost(messages) {
+  let cost_usd = 0;
+  let total_tokens = 0;
+
+  if (!Array.isArray(messages)) return { cost_usd: 0, total_tokens: 0 };
+
+  for (const msg of messages) {
+    const usage = msg?.usage || msg?.message?.usage;
+    if (!usage) continue;
+
+    const modelName = msg?.model || msg?.message?.model || '';
+    const prices = getModelPrice(modelName);
+
+    const inputTokens = usage.input_tokens || 0;
+    const outputTokens = usage.output_tokens || 0;
+
+    cost_usd += (inputTokens / 1_000_000) * prices.input;
+    cost_usd += (outputTokens / 1_000_000) * prices.output;
+    total_tokens += inputTokens + outputTokens;
+  }
+
+  return { cost_usd: Number(cost_usd.toFixed(6)), total_tokens };
+}
+
+// ---------------------------------------------------------------------------
+// Steering metrics
+// ---------------------------------------------------------------------------
+
+const CORRECTION_INDICATORS = [
+  'no ',
+  'instead',
+  'wait,',
+  'actually,',
+  "don't",
+  'stop,',
+  'go back',
+  'undo',
+  'revert',
+  "that's wrong",
+  '[request interrupted',
+];
+
+function classifyTurn(content) {
+  if (typeof content !== 'string') return 'progression';
+  const lower = content.toLowerCase();
+  for (const indicator of CORRECTION_INDICATORS) {
+    if (lower.includes(indicator)) return 'correction';
+  }
+  return 'progression';
+}
+
+function isToolResultBlock(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => block?.type === 'tool_result');
+}
+
+function computeSteeringMetrics(messages) {
+  if (!Array.isArray(messages)) return { turns_total: 0, turns_human: 0, turns_correction: 0, steering_ratio: 0 };
+
+  let turns_total = 0;
+  let turns_human = 0;
+  let turns_correction = 0;
+
+  for (const msg of messages) {
+    const message = msg?.message || msg;
+    const role = message?.role;
+    if (role !== 'user') continue;
+
+    turns_total += 1;
+
+    const content = message?.content;
+    // Skip tool result turns (not human-authored)
+    if (isToolResultBlock(content)) continue;
+
+    turns_human += 1;
+
+    const text = typeof content === 'string' ? content : (Array.isArray(content)
+      ? content.filter((b) => b?.type === 'text').map((b) => b.text).join(' ')
+      : '');
+
+    if (classifyTurn(text) === 'correction') {
+      turns_correction += 1;
+    }
+  }
+
+  const steering_ratio = turns_human > 0 ? Number((turns_correction / turns_human).toFixed(2)) : 0;
+
+  return { turns_total, turns_human, turns_correction, steering_ratio };
+}
+
+export {
+  extractRequestText,
+  tokenize,
+  classifyIntent,
+  isLikelyNoiseText,
+  MODEL_PRICES,
+  getModelPrice,
+  computeSessionCost,
+  CORRECTION_INDICATORS,
+  classifyTurn,
+  computeSteeringMetrics,
+};

package/lib/session/metadata.js

@@ -258,12 +258,18 @@ export async function getCurrentModel() {
 }
 
 /**
- * Extract all session metadata for a given working directory
+ * Extract all session metadata for a given working directory.
+ * @param {string} cwd - Working directory path
+ * @param {object} [hookInput] - Optional raw hook input (used to pull Cursor-specific
+ *   fields like model, is_background_agent, composer_mode directly from the event payload)
  */
-export async function extractSessionMetadata(cwd) {
+export async function extractSessionMetadata(cwd, hookInput = null) {
   const systemInfo = getSystemInfo();
   const isGit = isGitRepo(cwd);
-  const currentModel = await getCurrentModel();
+
+  // Prefer model from hook input (Cursor injects it in every event's common schema)
+  // over env vars and settings.json — more reliable for multi-client setups
+  const currentModel = hookInput?.model || await getCurrentModel();
 
   const metadata = {
     session_id: null, // Will be set by caller
@@ -274,16 +280,28 @@ export async function extractSessionMetadata(cwd) {
     commit_hash: isGit ? getCommitHash(cwd) : null,
     recent_commits: isGit ? getRecentCommits(cwd, 3) : [],
     current_task: isGit ? getCurrentTask(cwd) : null,
-    current_model: currentModel, // Claude model being used in this session
+    current_model: currentModel,
     hostname: systemInfo.hostname,
     username: systemInfo.username,
     platform: systemInfo.platform,
     node_version: systemInfo.nodeVersion,
-    is_git_repo: isGit
+    is_git_repo: isGit,
     // Note: started_at is intentionally NOT set here - it should only be set once
     // when the session is first created in the relay server, not on re-registration
   };
 
+  // Merge Cursor-specific fields when running inside Cursor IDE
+  if (hookInput?.cursor_version) {
+    metadata.client = 'cursor';
+    metadata.cursor_version = hookInput.cursor_version;
+    if (hookInput.is_background_agent !== undefined) {
+      metadata.is_background_agent = hookInput.is_background_agent;
+    }
+    if (hookInput.composer_mode) {
+      metadata.composer_mode = hookInput.composer_mode;
+    }
+  }
+
   return metadata;
 }
 

package/lib/transcript-sync/lifecycle.js

@@ -0,0 +1,88 @@
+/**
+ * Transcript Sync Lifecycle Management
+ *
+ * Thin adapter over @derivativelabs/agent-process.
+ * Provides start/stop/restart/status for transcript sync worker.
+ */
+
+import { agentStart, agentStop, agentStatus } from '@derivativelabs/agent-process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const AGENT_NAME = 'teleportation-transcript-sync';
+const WORKER_SCRIPT = join(__dirname, 'worker.js');
+
+export async function startTranscriptSync() {
+  const current = await getTranscriptSyncStatus();
+  if (current.running) {
+    throw new Error(`Transcript sync already running with PID ${current.pid}`);
+  }
+
+  const result = await agentStart({
+    name: AGENT_NAME,
+    script: WORKER_SCRIPT,
+    env: {
+      ...process.env,
+      TELEPORTATION_TRANSCRIPT_SYNC: 'true'
+    }
+  });
+
+  return {
+    pid: result.pid || null,
+    success: true
+  };
+}
+
+export async function stopTranscriptSync(options = {}) {
+  const current = await getTranscriptSyncStatus();
+  if (!current.running) {
+    return { success: true, forced: false };
+  }
+
+  try {
+    await agentStop(AGENT_NAME);
+    return { success: true, forced: false };
+  } catch (err) {
+    // Force handling is delegated to agent-process internals.
+    throw new Error(`Failed to stop transcript sync agent: ${err.message}`);
+  }
+}
+
+export async function restartTranscriptSync(options = {}) {
+  const { force = true } = options;
+  const current = await getTranscriptSyncStatus();
+  const wasRunning = current.running;
+
+  if (wasRunning) {
+    await stopTranscriptSync({ force });
+  }
+
+  const result = await startTranscriptSync();
+  return {
+    ...result,
+    wasRunning
+  };
+}
+
+export async function getTranscriptSyncStatus() {
+  try {
+    const status = await agentStatus(AGENT_NAME);
+    return {
+      running: status.state === 'online' || status.running || false,
+      pid: status.pid || null,
+      uptime: status.uptime || null
+    };
+  } catch {
+    return { running: false, pid: null, uptime: null };
+  }
+}
+
+export default {
+  startTranscriptSync,
+  stopTranscriptSync,
+  restartTranscriptSync,
+  getTranscriptSyncStatus
+};

package/lib/transcript-sync/repo-context.js

@@ -0,0 +1,45 @@
+import { homedir, hostname } from 'os';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { spawnSync } from 'child_process';
+
+function runGit(args, cwd) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 5000 });
+  if (result.status !== 0) {
+    return '';
+  }
+  return (result.stdout || '').trim();
+}
+
+function safeSlug(value) {
+  return (value || 'unknown-repo')
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64) || 'unknown-repo';
+}
+
+export function getRepoSyncContext(baseDir) {
+  const repoRoot = runGit(['rev-parse', '--show-toplevel'], baseDir) || baseDir;
+  const originUrl = runGit(['config', '--get', 'remote.origin.url'], repoRoot);
+  const peer = runGit(['config', '--get', 'teleportation.transcriptSyncPeer'], repoRoot) || null;
+  const machineId = (hostname() || 'unknown-machine').split('.')[0];
+
+  const repoIdentitySource = originUrl || repoRoot;
+  const repoHash = createHash('sha256').update(repoIdentitySource).digest('hex').slice(0, 12);
+  const repoName = safeSlug((originUrl.split('/').pop() || '').replace(/\.git$/, '') || repoRoot.split('/').pop());
+  const repoKey = `${repoName}-${repoHash}`;
+
+  const mirrorDir = join(homedir(), '.teleportation', 'transcript-mirror', 'repos', repoKey);
+  const peerMirrorDir = `~/.teleportation/transcript-mirror/repos/${repoKey}`;
+
+  return {
+    repoRoot,
+    repoKey,
+    originUrl: originUrl || null,
+    machineId,
+    peer,
+    mirrorDir,
+    peerMirrorDir
+  };
+}