@goodandready/dsh-context-lens 0.1.24 → 0.1.26

package/lib/tools.js

@@ -1,9 +1,8 @@
-import { compressLog, estimateTokens as estLog } from './compression/log-compressor.js';
 import { skeletonize } from './ast/skeletonizer.js';
-import * as tracker from './tokens/tracker.js';
+import { compressLog } from './compression/log-compressor.js';
 import { shouldAutoCompress } from './auto-compress.js';
 
-function normalizePath(p) {
+export function normalizePath(p) {
   return (p || '').replace(/\\/g, '/').replace(/\/+$/, '');
 }
 
@@ -17,7 +16,11 @@ export function isPathFocused(pattern, filePath) {
   return false;
 }
 
-export const OUTPUT_SCHEMA = { type: 'object', properties: { success: { type: 'boolean' } }, additionalProperties: true };
+export const OUTPUT_SCHEMA = {
+  type: 'object',
+  properties: { success: { type: 'boolean' } },
+  additionalProperties: true
+};
 
 // #71 (GH #2): output.render MUST return ContentBlock[] [{ type: 'text', text: ... }]
 export const renderOutput = (_args, result) => [
@@ -67,148 +70,131 @@ export function getFocusBySessionSize() {
   return focusBySession.size;
 }
 
-export function getLastActiveSession() {
-  return lastActiveSession;
-}
-
-export function registerTools(ctx, { getConfig, maybeTrack }) {
+export function registerTools(ctx, { getConfig } = {}) {
   if (!ctx?.tools?.register) return;
 
+  // Tool 1: Code semantic compression & focus management
   ctx.tools.register({
-    name: 'context_lens_focus',
-    description: 'Set active file paths for current session focus (these files skip AST compression)',
+    name: 'context_lens_code',
+    description: 'Semantic AST skeletonization of code (JS/TS/Python/Go/Rust/Java/C/C++/SQL) and path-based focus management',
     parameters: {
       type: 'object',
       properties: {
-        paths: { type: 'array', items: { type: 'string' }, description: 'File paths or patterns currently in focus' },
-        sessionId: { type: 'string', description: 'Session id (uses active session if omitted)' }
-      },
-      required: ['paths']
+        action: {
+          type: 'string',
+          enum: ['skeleton', 'focus', 'get_focus', 'clear_focus'],
+          description: "Action to perform: 'skeleton' (default: AST code skeleton), 'focus' (set session focus paths), 'get_focus' (view active focus), or 'clear_focus' (reset focus)"
+        },
+        code: { type: 'string', description: 'Source code to skeletonize (for action=skeleton)' },
+        language: { type: 'string', enum: ['js', 'ts', 'py', 'python', 'go', 'rust', 'java', 'c', 'cpp', 'sql'], description: 'Language hint for skeletonization' },
+        maxDepth: { type: 'number', description: 'Max depth for AST skeleton' },
+        filePath: { type: 'string', description: 'File path to check against focus paths (if in focus, returns full code without skeletonization)' },
+        paths: { type: 'array', items: { type: 'string' }, description: 'File paths or patterns to put in focus (for action=focus)' },
+        sessionId: { type: 'string', description: 'Session id for session-isolated focus' }
+      }
     },
     output: { schema: OUTPUT_SCHEMA, render: renderOutput },
     execute: async (params, meta) => {
+      const action = (params && params.action) || 'skeleton';
       const key = sessionKey(params, meta);
-      const rawPaths = Array.isArray(params.paths) ? params.paths : [];
-      const paths = rawPaths
-        .filter(p => typeof p === 'string')
-        .map(p => p.trim())
-        .filter(p => p.length > 0);
-      const state = getFocus(key);
-      state.paths = paths;
-      state.updatedAt = new Date().toISOString();
-      return { success: true, sessionId: key, focus: state };
-    }
-  });
 
-  ctx.tools.register({
-    name: 'context_lens_compress_log',
-    description: 'Compress a large log/test output block, keeping failures and stacktraces (Jest/Pytest/Go/npm)',
-    parameters: {
-      type: 'object',
-      properties: {
-        text: { type: 'string', description: 'Raw log text to compress' },
-        log: { type: 'string', description: 'Alias for text' },
-        mode: { type: 'string', enum: ['raw', 'balanced', 'aggressive'], description: 'Compression aggressiveness' },
-        maxLines: { type: 'number', description: 'Max output lines' },
-        auto: { type: 'boolean', description: 'Auto-compress if large (uses threshold); keeps configured compressionMode' }
+      if (action === 'focus') {
+        const rawPaths = Array.isArray(params?.paths) ? params.paths : [];
+        const paths = rawPaths
+          .filter(p => typeof p === 'string')
+          .map(p => p.trim())
+          .filter(p => p.length > 0);
+        const state = getFocus(key);
+        state.paths = paths;
+        state.updatedAt = new Date().toISOString();
+        return { success: true, action: 'focus', sessionId: key, focus: state };
       }
-    },
-    output: { schema: OUTPUT_SCHEMA, render: renderOutput },
-    execute: async (params) => {
-      const cfg = getConfig();
-      const inputText = params.text || params.log || '';
-      const mode = params.mode || cfg.compressionMode || 'balanced';
-      const maxLines = params.maxLines || 400;
-      const threshold = cfg.autoCompressThreshold ?? 4000;
-      const useAuto = params.auto !== false && shouldAutoCompress(inputText, threshold);
-      const effectiveMode = mode;
-      const res = compressLog(inputText, { mode: effectiveMode, maxLines });
-      maybeTrack(inputText, res.compressed);
-      return { success: true, mode: effectiveMode, autoCompressed: useAuto, ...res };
-    }
-  });
 
-  ctx.tools.register({
-    name: 'context_lens_compress_code',
-    description: 'Generate AST skeleton for a large source file (JS/TS/Python/Go/Rust/Java/C/C++/SQL) to save context',
-    parameters: {
-      type: 'object',
-      properties: {
-        code: { type: 'string', description: 'Source code to skeletonize' },
-        language: { type: 'string', enum: ['js', 'ts', 'py', 'python', 'go', 'rust', 'java', 'c', 'cpp', 'sql'], description: 'Language hint' },
-        maxDepth: { type: 'number', description: 'Max depth' },
-        filePath: { type: 'string', description: 'File path to check focus (if in focus, returns full code)' },
-        sessionId: { type: 'string', description: 'Session id for focus lookup' }
-      },
-      required: ['code']
-    },
-    output: { schema: OUTPUT_SCHEMA, render: renderOutput },
-    execute: async (params, meta) => {
-      const cfg = getConfig();
-      const maxDepth = params.maxDepth ?? cfg.astSkeletonMaxDepth ?? 3;
-      const key = sessionKey(params, meta);
+      if (action === 'get_focus') {
+        return { success: true, action: 'get_focus', sessionId: key, focus: getFocus(key) };
+      }
+
+      if (action === 'clear_focus') {
+        clearFocus(key);
+        return { success: true, action: 'clear_focus', sessionId: key, focus: getFocus(key) };
+      }
+
+      // Default: skeleton
+      const cfg = getConfig ? getConfig() : {};
+      const maxDepth = params?.maxDepth ?? cfg.astSkeletonMaxDepth ?? 3;
+      const code = params?.code || '';
+      const rawFilePath = typeof params?.filePath === 'string' ? params.filePath.trim() : '';
       const focusState = getFocus(key);
-      const rawFilePath = typeof params.filePath === 'string' ? params.filePath.trim() : '';
       const isFocused = rawFilePath && focusState.paths.length > 0
         ? focusState.paths.some(p => isPathFocused(p, rawFilePath))
         : false;
+
       if (isFocused) {
-        maybeTrack(params.code, params.code);
-        return { success: true, skeleton: params.code, originalTokens: estLog(params.code), skeletonTokens: estLog(params.code), maxDepth, focused: true, sessionId: key, hint: 'File is in focus, returned full code' };
+        return {
+          success: true,
+          action: 'skeleton',
+          skeleton: code,
+          maxDepth,
+          focused: true,
+          sessionId: key,
+          hint: 'File is in focus, returned full code'
+        };
       }
-      const skeleton = skeletonize(params.code, { maxDepth, language: params.language });
-      maybeTrack(params.code, skeleton);
-      return { success: true, skeleton, originalTokens: estLog(params.code), skeletonTokens: estLog(skeleton), maxDepth, focused: false, sessionId: key };
+
+      const skeleton = skeletonize(code, { maxDepth, language: params?.language });
+      return {
+        success: true,
+        action: 'skeleton',
+        skeleton,
+        maxDepth,
+        focused: false,
+        sessionId: key
+      };
     }
   });
 
+  // Tool 2: Test & build log compression
   ctx.tools.register({
-    name: 'context_lens_reset',
-    description: 'Reset context-lens savings stats and history (e.g. at the start of a new task)',
+    name: 'context_lens_log',
+    description: 'Compress test and build output logs, keeping failures, stack traces, and summary',
     parameters: {
       type: 'object',
       properties: {
-        sessionId: { type: 'string', description: 'Optional session id to also reset session focus' }
+        text: { type: 'string', description: 'Raw log text to compress' },
+        log: { type: 'string', description: 'Alias for text' },
+        mode: { type: 'string', enum: ['raw', 'balanced', 'aggressive'], description: 'Compression mode (default: balanced)' },
+        maxLines: { type: 'number', description: 'Max output lines' },
+        auto: { type: 'boolean', description: 'Auto-compress only if large and matches test/build signatures' },
+        command: { type: 'string', description: 'Command that generated output (used to identify test/build logs in auto mode)' }
       }
     },
     output: { schema: OUTPUT_SCHEMA, render: renderOutput },
-    execute: async (params, meta) => {
-      tracker.reset();
-      const key = sessionKey(params || {}, meta);
-      if (params && params.sessionId) {
-        focusBySession.delete(key);
-      }
-      return { success: true, message: 'Context lens stats and history reset', sessionId: key };
-    }
-  });
+    execute: async (params) => {
+      const cfg = getConfig ? getConfig() : {};
+      const inputText = params?.text || params?.log || '';
+      const mode = params?.mode || cfg.compressionMode || 'balanced';
+      const maxLines = params?.maxLines || 400;
+      const threshold = cfg.autoCompressThreshold ?? 4000;
 
-  ctx.tools.register({
-    name: 'context_lens_stats',
-    description: 'Show session token savings stats for context-lens',
-    parameters: {
-      type: 'object',
-      properties: {
-        sessionId: { type: 'string', description: 'Session id for focus snapshot' }
+      if (params?.auto === true) {
+        if (!shouldAutoCompress(inputText, threshold, params?.command)) {
+          return {
+            success: true,
+            mode,
+            autoCompressed: false,
+            compressed: inputText,
+            skipped: true,
+            reason: 'Not recognized as test/build output or below threshold; preserved for core pruner'
+          };
+        }
       }
-    },
-    output: { schema: OUTPUT_SCHEMA, render: renderOutput },
-    execute: async (params, meta) => {
-      const cfg = getConfig();
-      if (typeof cfg.budgetLimit === 'number') tracker.setBudgetLimit(cfg.budgetLimit);
-      if (typeof cfg.budgetAlertPercent === 'number') tracker.setBudgetAlertPercent(cfg.budgetAlertPercent);
-      const stats = tracker.getStats(cfg.budgetLimit, cfg.budgetAlertPercent);
-      const history = tracker.getHistory();
-      const key = sessionKey(params || {}, meta);
+
+      const res = compressLog(inputText, { mode, maxLines });
       return {
         success: true,
-        ...stats,
-        history,
-        trackingEnabled: cfg.tokenSavingsTracking !== false,
-        autoCollapse: cfg.autoCollapse !== false,
-        focus: getFocus(key),
-        sessionId: key,
-        autoCompressThreshold: cfg.autoCompressThreshold,
-        budgetAlertPercent: cfg.budgetAlertPercent ?? 90
+        mode,
+        autoCompressed: params?.auto === true,
+        ...res
       };
     }
   });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodandready/dsh-context-lens",
-  "version": "0.1.24",
-  "description": "DSH plugin for AST context compression, test log filtering, and token budget guard",
+  "version": "0.1.26",
+  "description": "DSH plugin for semantic AST code skeletonization and test/build log compression",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -26,9 +26,9 @@
     "dsh",
     "dsh-plugin",
     "context",
-    "token-guard",
     "ast-compression",
-    "log-filter"
+    "log-compression",
+    "semantic-compression"
   ],
   "repository": {
     "type": "git",
@@ -54,15 +54,8 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.18.1",
-    "dsh-better-sidebar": "^0.18.0-alpha.0"
-  },
-  "peerDependenciesMeta": {
-    "dsh-better-sidebar": {
-      "optional": true
-    }
+    "@deepseek-ai/schemastery": "^3.18.1"
   }
 }

package/lib/http.js

@@ -1,114 +0,0 @@
-export function writeJson(res, code, body) {
-  try {
-    res.writeHead(code, {
-      'Content-Type': 'application/json; charset=utf-8',
-      'Cache-Control': 'no-store',
-    });
-    res.end(JSON.stringify(body));
-  } catch {
-    /* socket already closed */
-  }
-}
-
-export function readBody(req, maxBytes = 256 * 1024) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    let size = 0;
-    req.on('data', (c) => {
-      size += c.length;
-      if (size > maxBytes) {
-        req.destroy();
-        reject(new Error('body too large'));
-        return;
-      }
-      chunks.push(c);
-    });
-    req.on('end', () => resolve(Buffer.concat(chunks)));
-    req.on('error', reject);
-  });
-}
-
-export function header(request, name) {
-  const value = request?.headers?.[name.toLowerCase()];
-  return Array.isArray(value) ? value[0] : value;
-}
-
-export function isLoopbackAddress(value) {
-  const address = String(value || '').toLowerCase().replace(/^\[|\]$/g, '');
-  return address === 'localhost' || address === 'localhost.' || address === '::1'
-    || address.startsWith('127.')
-    || address.startsWith('::ffff:127.');
-}
-
-/** Reject cross-site writes while allowing local, LAN, and reverse-proxy UIs. */
-export function isTrustedRequest(request) {
-  const secFetchSite = header(request, 'sec-fetch-site');
-  if (secFetchSite === 'cross-site') {
-    return false;
-  }
-
-  const host = header(request, 'x-forwarded-host') || header(request, 'host');
-  const origin = header(request, 'origin');
-  if (origin) {
-    try {
-      const url = new URL(origin);
-      if (host && url.host.toLowerCase() === host.toLowerCase()) {
-        return true;
-      }
-      if (isLoopbackAddress(url.hostname) && isLoopbackAddress(request?.socket?.remoteAddress)) {
-        return true;
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  const referer = header(request, 'referer');
-  if (referer) {
-    try {
-      const url = new URL(referer);
-      if (host && url.host.toLowerCase() === host.toLowerCase()) {
-        return true;
-      }
-      if (isLoopbackAddress(url.hostname) && isLoopbackAddress(request?.socket?.remoteAddress)) {
-        return true;
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  // Requests without origin/referer (e.g. curl, loopback tests, or internal calls)
-  if (isLoopbackAddress(request?.socket?.remoteAddress)) {
-    return true;
-  }
-
-  if (secFetchSite === 'same-origin' || secFetchSite === 'same-site') {
-    return true;
-  }
-
-  return false;
-}
-
-export const UPDATE_HEADER = 'x-dsh-plugin-update';
-export const ALT_UPDATE_HEADER = 'x-dsh-context-lens-update';
-
-export function isTrustedUpdateRequest(request) {
-  const updHdr = header(request, UPDATE_HEADER) || header(request, ALT_UPDATE_HEADER);
-  if (updHdr !== '1') return false;
-  if (!isLoopbackAddress(request?.socket?.remoteAddress)) return false;
-  const site = header(request, 'sec-fetch-site');
-  if (site !== undefined && site !== 'same-origin') return false;
-  const origin = header(request, 'origin');
-  const host = header(request, 'host');
-  if (origin === undefined || host === undefined) return false;
-  try {
-    const url = new URL(origin);
-    return (url.protocol === 'http:' || url.protocol === 'https:')
-      && isLoopbackAddress(url.hostname) && url.host === host;
-  } catch {
-    return false;
-  }
-}

package/lib/tokens/estimate.js

@@ -1,6 +0,0 @@
-// shared token estimate (~chars/4)
-export function estimateTokens(text) {
-  return Math.ceil((text || '').length / 4);
-}
-
-export default { estimateTokens };

package/lib/tokens/tracker.js

@@ -1,89 +0,0 @@
-// ponytail: in-memory per-process tracker + history, no DB
-import { estimateTokens } from './estimate.js';
-
-let totalOriginal = 0;
-let totalCompressed = 0;
-let calls = 0;
-const history = []; // last 10
-const MAX_HISTORY = 10;
-let defaultBudgetLimit = 100000; // tokens
-let defaultBudgetAlertPercent = 90; // threshold percent for low budget warning
-
-export { estimateTokens };
-
-export function setBudgetLimit(limit) {
-  if (typeof limit === 'number' && limit > 0) {
-    defaultBudgetLimit = limit;
-  }
-}
-
-export function setBudgetAlertPercent(percent) {
-  if (typeof percent === 'number' && percent >= 50 && percent <= 99) {
-    defaultBudgetAlertPercent = percent;
-  }
-}
-
-export function record(originalText, compressedText) {
-  const o = estimateTokens(originalText);
-  const c = estimateTokens(compressedText);
-  const saved = Math.max(0, o - c);
-  // #34: stop counting after budgetLimit (description promised this)
-  if (totalCompressed >= defaultBudgetLimit) {
-    return { originalTokens: o, compressedTokens: c, savedTokens: 0, stopped: true };
-  }
-  totalOriginal += o;
-  totalCompressed += c;
-  calls++;
-  const entry = {
-    id: Date.now() + Math.random().toString(36).slice(2, 6),
-    originalTokens: o,
-    compressedTokens: c,
-    savedTokens: saved,
-    savedPercent: o ? Math.round((1 - c / o) * 100) : 0,
-    timestamp: new Date().toISOString(),
-    preview: (compressedText || '').slice(0, 120)
-  };
-  history.unshift(entry);
-  if (history.length > MAX_HISTORY) history.pop();
-  return { originalTokens: o, compressedTokens: c, savedTokens: saved };
-}
-
-export function getStats(budgetLimitOverride, budgetAlertPercentOverride) {
-  const limit = (typeof budgetLimitOverride === 'number' && budgetLimitOverride > 0)
-    ? budgetLimitOverride
-    : defaultBudgetLimit;
-  const alertPercent = (typeof budgetAlertPercentOverride === 'number' && budgetAlertPercentOverride >= 50 && budgetAlertPercentOverride <= 99)
-    ? budgetAlertPercentOverride
-    : defaultBudgetAlertPercent;
-  const saved = Math.max(0, totalOriginal - totalCompressed);
-  const pct = totalOriginal ? Math.round((1 - totalCompressed / totalOriginal) * 100) : 0;
-  const budgetUsed = totalCompressed;
-  const budgetRemaining = Math.max(0, limit - budgetUsed);
-  const budgetPercent = Math.min(100, Math.round((budgetUsed / limit) * 100));
-  const lowBudget = budgetPercent >= alertPercent;
-  return {
-    totalOriginal,
-    totalCompressed,
-    savedTokens: saved,
-    savedPercent: pct,
-    calls,
-    budgetUsed,
-    budgetRemaining,
-    budgetPercent,
-    lowBudget,
-    budgetLimit: limit,
-    budgetAlertPercent: alertPercent,
-    countingStopped: budgetUsed >= limit
-  };
-}
-
-export function getHistory() {
-  return [...history];
-}
-
-export function reset() {
-  totalOriginal = 0;
-  totalCompressed = 0;
-  calls = 0;
-  history.length = 0;
-}