@colin4k1024/tsp 2.5.3 → 2.5.4

package/scripts/hooks/suggest-compact.js

@@ -12,6 +12,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const contextWindow = require('../lib/context-window');
 
 const AUTO_COMPACT_BUFFER_PCT = 16.5;
 const DEFAULT_CONTEXT_LIMIT = 200000;
@@ -98,119 +99,7 @@ function readBridgeMetrics(sessionId) {
 }
 
 function resolveContextMetrics(data) {
-  const contextLimit = toNumber(process.env.CLAUDE_CONTEXT_LIMIT) || DEFAULT_CONTEXT_LIMIT;
-  let cw = {};
-  if (data.context_window && typeof data.context_window === 'object') {
-    cw = data.context_window;
-  } else if (data.context_window != null) {
-    // Malformed: context_window is present but not an object.
-    // Attempt to extract a numeric value (some Claude Code versions
-    // may pass context_size as a bare number).
-    const numericValue = toNumber(data.context_window);
-    if (numericValue != null && numericValue > 0) {
-      const usagePct = clampPct((numericValue / contextLimit) * 100);
-      return {
-        usagePct,
-        remainingPct: null,
-        contextLimit,
-        contextSize: numericValue,
-        source: 'stdin.context_window_raw',
-      };
-    }
-    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
-      process.stderr.write(
-        `[strategic-compact] context_window is ${typeof data.context_window}: ${JSON.stringify(data.context_window).slice(0, 100)}\n`
-      );
-    }
-  }
-
-  const stdinUsed = toNumber(cw.used_percentage);
-  if (stdinUsed != null) {
-    const usagePct = clampPct(stdinUsed);
-    return {
-      usagePct,
-      remainingPct: toNumber(cw.remaining_percentage),
-      contextLimit,
-      contextSize: Math.round((usagePct / 100) * contextLimit),
-      source: 'stdin.used_percentage',
-    };
-  }
-
-  const stdinRemaining = toNumber(cw.remaining_percentage);
-  if (stdinRemaining != null) {
-    const usagePct = normalizeRemainingToUsed(stdinRemaining);
-    return {
-      usagePct,
-      remainingPct: clampPct(stdinRemaining),
-      contextLimit,
-      contextSize: Math.round((usagePct / 100) * contextLimit),
-      source: 'stdin.remaining_percentage',
-    };
-  }
-
-  const envSize = toNumber(process.env.CLAUDE_CONTEXT_SIZE);
-  if (envSize != null && envSize > 0) {
-    const usagePct = clampPct((envSize / contextLimit) * 100);
-    return {
-      usagePct,
-      remainingPct: null,
-      contextLimit,
-      contextSize: envSize,
-      source: 'env',
-    };
-  }
-
-  // Transcript JSONL usage parsing (CCometixLine approach)
-  const transcriptPath = data.transcript_path;
-  const modelId = (data.model && data.model.id) || process.env.CLAUDE_MODEL || null;
-  if (transcriptPath && typeof transcriptPath === 'string') {
-    try {
-      const { resolveTranscriptMetrics } = require('../lib/transcript-usage');
-      const transcriptMetrics = resolveTranscriptMetrics(transcriptPath, modelId);
-      if (transcriptMetrics) {
-        return {
-          usagePct: clampPct(transcriptMetrics.usagePct),
-          remainingPct: null,
-          contextLimit: transcriptMetrics.contextLimit,
-          contextSize: transcriptMetrics.contextTokens,
-          source: 'transcript_usage',
-        };
-      }
-    } catch (_) {
-      // transcript parsing failed — fall through
-    }
-  }
-
-  const bridge = readBridgeMetrics(sessionKey(data));
-  if (bridge) {
-    return {
-      ...bridge,
-      contextLimit,
-      contextSize: Math.round((bridge.usagePct / 100) * contextLimit),
-    };
-  }
-
-  // Final fallback: estimate from transcript file size
-  if (transcriptPath && typeof transcriptPath === 'string') {
-    try {
-      const stat = fs.statSync(transcriptPath);
-      const estimatedTokens = Math.round(stat.size * 0.25);
-      if (estimatedTokens > 0) {
-        const usagePct = clampPct((estimatedTokens / contextLimit) * 100);
-        return {
-          usagePct,
-          remainingPct: null,
-          contextLimit,
-          contextSize: estimatedTokens,
-          source: 'transcript_size',
-        };
-      }
-    } catch (_) {
-      // transcript not accessible — fall through
-    }
-  }
-
-  return null;
+  return contextWindow.resolveContextMetrics(data);
 }
 
 function buildSuggestions(usagePct, contextSize) {
@@ -329,8 +218,9 @@ function shouldEmit(sessionId, urgency, usagePct) {
   }
 }
 
-function buildContextMessage({ usagePct, remainingPct, urgency, savings, suggestions, source }) {
+function buildContextMessage({ usagePct, remainingPct, compactCount, urgency, savings, suggestions, source }) {
   const remainingPart = remainingPct == null ? '' : ` | remaining: ${clampPct(remainingPct)}%`;
+  const compactPart = compactCount == null ? '' : ` | compact count: ${compactCount}`;
   const actionByUrgency = {
     advisory: 'Context usage is approaching the compaction threshold. Be mindful of context budget; avoid starting large new explorations.',
     medium: 'Finish the current small step, then run `/compact` before more broad reading or implementation.',
@@ -340,7 +230,7 @@ function buildContextMessage({ usagePct, remainingPct, urgency, savings, suggest
 
   return [
     '## Strategic Compact Triggered',
-    `- Context usage: ${usagePct}%${remainingPart} | urgency: ${urgency} | source: ${source}`,
+    `- Context usage: ${usagePct}%${remainingPart}${compactPart} | urgency: ${urgency} | source: ${source}`,
     `- Action: ${actionByUrgency[urgency] || actionByUrgency.medium}`,
     `- Estimated savings: ~${savings} tokens`,
     ...suggestions.map(item => `- ${item.action}: ${item.target} - ${item.reason}`),
@@ -394,6 +284,7 @@ function buildHookOutput(rawInput) {
   const additionalContext = buildContextMessage({
     usagePct: metrics.usagePct,
     remainingPct: metrics.remainingPct,
+    compactCount: metrics.compactCount,
     urgency,
     savings,
     suggestions,
@@ -409,6 +300,9 @@ function buildHookOutput(rawInput) {
       should_compact: true,
       urgency,
       context_usage_ratio: metrics.usagePct,
+      context_remaining_percentage: metrics.remainingPct,
+      context_remaining_tokens: metrics.remainingTokens,
+      compact_count: metrics.compactCount,
       context_source: metrics.source,
       estimated_token_savings: savings,
       suggestions,

package/scripts/lib/completion-oracle.js

@@ -2,8 +2,7 @@
 
 const crypto = require('crypto');
 const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
+const loopStateStore = require('./loop-state-store');
 
 const GOAL_STATES = {
   active: 'active',
@@ -236,38 +235,16 @@ function resumeGoal(goal) {
   }
 }
 
-// Goal persistence
-
-function getGoalsDir() {
-  const home = process.env.HOME || process.env.USERPROFILE;
-  const dir = path.join(home, '.claude', 'goals');
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-
 function saveGoal(goal) {
-  const filePath = path.join(getGoalsDir(), `${goal.goalId}.json`);
-  fs.writeFileSync(filePath, JSON.stringify(goal, null, 2), 'utf-8');
-  return filePath;
+  return loopStateStore.saveGoal(goal);
 }
 
 function loadGoal(goalId) {
-  const filePath = path.join(getGoalsDir(), `${goalId}.json`);
-  if (!fs.existsSync(filePath)) return null;
-  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  return loopStateStore.loadGoal(goalId);
 }
 
 function listGoals(filter) {
-  const dir = getGoalsDir();
-  if (!fs.existsSync(dir)) return [];
-
-  return fs.readdirSync(dir)
-    .filter(f => f.endsWith('.json'))
-    .map(f => JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8')))
-    .filter(g => !filter || g.state === filter)
-    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  return loopStateStore.listGoals(filter);
 }
 
 function getActiveGoals() {

package/scripts/lib/context-window-state.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+function sanitizeSegment(raw, fallback = 'default') {
+  const value = String(raw || '').trim();
+  if (!value) return fallback;
+  const sanitized = value
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(-80);
+  return sanitized || crypto.createHash('sha256').update(value).digest('hex').slice(0, 16);
+}
+
+function projectStateDir(cwd = process.cwd()) {
+  return path.join(path.resolve(cwd || process.cwd()), '.tsp', 'context');
+}
+
+function getContextStateDir(options = {}) {
+  if (process.env.TSP_CONTEXT_STATE_DIR) {
+    return path.resolve(process.env.TSP_CONTEXT_STATE_DIR);
+  }
+  if (options.stateDir) {
+    return path.resolve(options.stateDir);
+  }
+  if (options.projectRoot || options.cwd) {
+    return projectStateDir(options.projectRoot || options.cwd);
+  }
+  return projectStateDir(process.cwd());
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function getCompactStatePath(options = {}) {
+  return path.join(getContextStateDir(options), 'compact-state.json');
+}
+
+function readJson(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (_) {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+function resolveSessionId(input = {}, options = {}) {
+  return sanitizeSegment(
+    options.sessionId ||
+    input.session_id ||
+    input.sessionId ||
+    process.env.CLAUDE_SESSION_ID ||
+    process.env.CODEX_SESSION_ID ||
+    'default'
+  );
+}
+
+function emptyState() {
+  return {
+    version: 1,
+    totalCompactCount: 0,
+    sessions: {},
+    updatedAt: null,
+  };
+}
+
+function loadCompactState(options = {}) {
+  return readJson(getCompactStatePath(options), emptyState());
+}
+
+function getSessionCompactCount(input = {}, options = {}) {
+  const state = loadCompactState(options);
+  const sessionId = resolveSessionId(input, options);
+  return Number(state.sessions?.[sessionId]?.compactCount || 0) || 0;
+}
+
+function recordCompactEvent(input = {}, options = {}) {
+  const statePath = getCompactStatePath(options);
+  const state = loadCompactState(options);
+  const sessionId = resolveSessionId(input, options);
+  const now = new Date().toISOString();
+  const current = state.sessions[sessionId] || {
+    sessionId,
+    compactCount: 0,
+    firstCompactedAt: now,
+  };
+
+  current.compactCount = (Number(current.compactCount || 0) || 0) + 1;
+  current.lastCompactedAt = now;
+  current.transcriptPath = input.transcript_path || input.transcriptPath || current.transcriptPath || null;
+  current.cwd = input.cwd || input.workspace?.current_dir || options.cwd || process.cwd();
+
+  state.version = 1;
+  state.totalCompactCount = (Number(state.totalCompactCount || 0) || 0) + 1;
+  state.sessions[sessionId] = current;
+  state.updatedAt = now;
+
+  writeJson(statePath, state);
+
+  return {
+    statePath,
+    sessionId,
+    sessionCompactCount: current.compactCount,
+    totalCompactCount: state.totalCompactCount,
+    updatedAt: now,
+  };
+}
+
+module.exports = {
+  getContextStateDir,
+  getCompactStatePath,
+  loadCompactState,
+  getSessionCompactCount,
+  recordCompactEvent,
+  resolveSessionId,
+};

package/scripts/lib/context-window.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { resolveTranscriptMetrics, resolveContextLimit } = require('./transcript-usage');
+const { getSessionCompactCount, resolveSessionId } = require('./context-window-state');
+
+const AUTO_COMPACT_BUFFER_PCT = 16.5;
+const STALE_BRIDGE_SECONDS = 120;
+
+function toNumber(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+
+function clampPct(value) {
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+function normalizeRemainingToUsed(remainingPct) {
+  const usableRemaining = Math.max(
+    0,
+    ((remainingPct - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100
+  );
+  return clampPct(100 - usableRemaining);
+}
+
+function firstNumber(object, keys) {
+  if (!object || typeof object !== 'object') return null;
+  for (const key of keys) {
+    const value = toNumber(object[key]);
+    if (value != null) return value;
+  }
+  return null;
+}
+
+function modelIdFromInput(data = {}) {
+  return data.model?.id || data.model?.name || process.env.CLAUDE_MODEL || null;
+}
+
+function contextLimitFrom(data, candidate) {
+  return (
+    firstNumber(candidate, ['context_limit', 'contextLimit', 'limit', 'model_context_window']) ||
+    firstNumber(data, ['context_limit', 'contextLimit']) ||
+    resolveContextLimit(modelIdFromInput(data))
+  );
+}
+
+function metricFromCandidate(data, candidate, source) {
+  if (!candidate || typeof candidate !== 'object') return null;
+
+  const contextLimit = contextLimitFrom(data, candidate);
+  let remainingPct = firstNumber(candidate, [
+    'remaining_percentage',
+    'remainingPercentage',
+    'remaining_pct',
+    'remainingPct',
+    'remaining_percent',
+  ]);
+  let usagePct = firstNumber(candidate, [
+    'used_percentage',
+    'usedPercentage',
+    'used_pct',
+    'usedPct',
+    'usagePct',
+    'usage_percentage',
+  ]);
+  let remainingTokens = firstNumber(candidate, [
+    'remaining_tokens',
+    'remainingTokens',
+    'available_tokens',
+    'availableTokens',
+  ]);
+  let contextTokens = firstNumber(candidate, [
+    'context_tokens',
+    'contextTokens',
+    'used_tokens',
+    'usedTokens',
+  ]);
+
+  if (remainingPct == null && remainingTokens != null && contextLimit > 0) {
+    remainingPct = (remainingTokens / contextLimit) * 100;
+  }
+  if (remainingTokens == null && remainingPct != null && contextLimit > 0) {
+    remainingTokens = Math.max(0, Math.round((remainingPct / 100) * contextLimit));
+  }
+  if (usagePct == null && remainingPct != null) {
+    usagePct = normalizeRemainingToUsed(remainingPct);
+  }
+  if (remainingPct == null && usagePct != null) {
+    remainingPct = clampPct(100 - usagePct);
+  }
+  if (contextTokens == null && remainingTokens != null && contextLimit > 0) {
+    contextTokens = Math.max(0, contextLimit - remainingTokens);
+  }
+  if (contextTokens == null && usagePct != null && contextLimit > 0) {
+    contextTokens = Math.round((usagePct / 100) * contextLimit);
+  }
+
+  if (usagePct == null && contextTokens == null && remainingPct == null) return null;
+
+  return {
+    usagePct: usagePct != null ? clampPct(usagePct) : clampPct((contextTokens / contextLimit) * 100),
+    remainingPct: remainingPct != null ? clampPct(remainingPct) : null,
+    remainingTokens: remainingTokens != null ? Math.max(0, Math.round(remainingTokens)) : null,
+    contextLimit,
+    contextSize: contextTokens != null ? Math.max(0, Math.round(contextTokens)) : 0,
+    source,
+  };
+}
+
+function readJsonEnv(names) {
+  for (const name of names) {
+    const raw = process.env[name];
+    if (!raw) continue;
+    try {
+      return { name, value: JSON.parse(raw) };
+    } catch (_) {
+      continue;
+    }
+  }
+  return null;
+}
+
+function readJsonFileEnv(names) {
+  for (const name of names) {
+    const filePath = process.env[name];
+    if (!filePath) continue;
+    try {
+      return { name, value: JSON.parse(fs.readFileSync(filePath, 'utf8')) };
+    } catch (_) {
+      continue;
+    }
+  }
+  return null;
+}
+
+function explicitFrameworkCandidates(data = {}) {
+  const candidates = [];
+  const envJson = readJsonEnv(['TSP_CONTEXT_WINDOW_JSON', 'CCOMETIXLINE_CONTEXT_JSON']);
+  if (envJson) candidates.push([envJson.value, `env.${envJson.name}`]);
+
+  const fileJson = readJsonFileEnv(['TSP_CONTEXT_WINDOW_FILE', 'CCOMETIXLINE_CONTEXT_FILE']);
+  if (fileJson) candidates.push([fileJson.value, `file.${fileJson.name}`]);
+
+  if (data.ccometixline?.context_window) candidates.push([data.ccometixline.context_window, 'stdin.ccometixline.context_window']);
+  if (data.ccometixline?.contextWindow) candidates.push([data.ccometixline.contextWindow, 'stdin.ccometixline.contextWindow']);
+  if (data.ccometixline_context_window) candidates.push([data.ccometixline_context_window, 'stdin.ccometixline_context_window']);
+  if (data.context_metrics) candidates.push([data.context_metrics, 'stdin.context_metrics']);
+
+  return candidates;
+}
+
+function readBridgeMetrics(data = {}) {
+  const sessionId = resolveSessionId(data);
+  if (!sessionId) return null;
+
+  const bridgePath = path.join(os.tmpdir(), `harness-ctx-${sessionId}.json`);
+  if (!fs.existsSync(bridgePath)) return null;
+
+  try {
+    const bridge = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+    const now = Math.floor(Date.now() / 1000);
+    if (bridge.timestamp && now - bridge.timestamp > STALE_BRIDGE_SECONDS) return null;
+    return metricFromCandidate(data, bridge, 'bridge');
+  } catch (_) {
+    return null;
+  }
+}
+
+function transcriptMetrics(data = {}) {
+  const transcriptPath = data.transcript_path;
+  if (!transcriptPath || typeof transcriptPath !== 'string') return null;
+
+  const metrics = resolveTranscriptMetrics(transcriptPath, modelIdFromInput(data));
+  if (!metrics) return null;
+
+  return {
+    usagePct: clampPct(metrics.usagePct),
+    remainingPct: metrics.remainingPct,
+    remainingTokens: metrics.remainingTokens,
+    contextLimit: metrics.contextLimit,
+    contextSize: metrics.contextTokens,
+    source: 'transcript_usage',
+  };
+}
+
+function transcriptSizeMetrics(data = {}) {
+  const transcriptPath = data.transcript_path;
+  if (!transcriptPath || typeof transcriptPath !== 'string') return null;
+
+  try {
+    const stat = fs.statSync(transcriptPath);
+    const estimatedTokens = Math.round(stat.size * 0.25);
+    if (estimatedTokens <= 0) return null;
+    const contextLimit = resolveContextLimit(modelIdFromInput(data));
+    const usagePct = clampPct((estimatedTokens / contextLimit) * 100);
+    return {
+      usagePct,
+      remainingPct: clampPct(100 - usagePct),
+      remainingTokens: Math.max(0, contextLimit - estimatedTokens),
+      contextLimit,
+      contextSize: estimatedTokens,
+      source: 'transcript_size',
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+function fallbackSessionKey(data = {}) {
+  const raw = data.session_id || process.env.CLAUDE_SESSION_ID;
+  if (typeof raw === 'string' && raw.trim()) {
+    return raw.replace(/[^a-zA-Z0-9_-]/g, '').slice(-64) || 'default';
+  }
+
+  const pidKey = `pid-${process.pid}`;
+  const cwd = data.cwd || process.cwd();
+  const cwdHash = crypto.createHash('sha256').update(String(cwd)).digest('hex').slice(0, 16);
+  return `${pidKey}-${cwdHash}`;
+}
+
+function attachCompactState(metrics, data = {}) {
+  if (!metrics) return null;
+  return {
+    ...metrics,
+    compactCount: getSessionCompactCount(data, { cwd: data.cwd || data.workspace?.current_dir || process.cwd() }),
+  };
+}
+
+function resolveContextMetrics(data = {}) {
+  for (const [candidate, source] of explicitFrameworkCandidates(data)) {
+    const metrics = metricFromCandidate(data, candidate, source);
+    if (metrics) return attachCompactState(metrics, data);
+  }
+
+  if (data.context_window && typeof data.context_window === 'object') {
+    const contextWindowSource = firstNumber(data.context_window, ['used_percentage', 'usedPercentage']) != null
+      ? 'stdin.used_percentage'
+      : 'stdin.remaining_percentage';
+    const metrics = metricFromCandidate(data, data.context_window, contextWindowSource);
+    if (metrics) return attachCompactState(metrics, data);
+  } else if (data.context_window != null) {
+    const numericValue = toNumber(data.context_window);
+    const contextLimit = resolveContextLimit(modelIdFromInput(data));
+    if (numericValue != null && numericValue > 0) {
+      return attachCompactState({
+        usagePct: clampPct((numericValue / contextLimit) * 100),
+        remainingPct: null,
+        remainingTokens: null,
+        contextLimit,
+        contextSize: numericValue,
+        source: 'stdin.context_window_raw',
+      }, data);
+    }
+  }
+
+  const envSize = toNumber(process.env.CLAUDE_CONTEXT_SIZE);
+  if (envSize != null && envSize > 0) {
+    const contextLimit = toNumber(process.env.CLAUDE_CONTEXT_LIMIT) || resolveContextLimit(modelIdFromInput(data));
+    const usagePct = clampPct((envSize / contextLimit) * 100);
+    return attachCompactState({
+      usagePct,
+      remainingPct: clampPct(100 - usagePct),
+      remainingTokens: Math.max(0, contextLimit - envSize),
+      contextLimit,
+      contextSize: envSize,
+      source: 'env',
+    }, data);
+  }
+
+  return attachCompactState(
+    transcriptMetrics(data) ||
+    readBridgeMetrics(data) ||
+    transcriptSizeMetrics(data),
+    data
+  );
+}
+
+module.exports = {
+  AUTO_COMPACT_BUFFER_PCT,
+  toNumber,
+  clampPct,
+  normalizeRemainingToUsed,
+  metricFromCandidate,
+  resolveContextMetrics,
+  fallbackSessionKey,
+};