@goodandready/dsh-context-lens 0.1.25 → 0.1.26

package/lib/compression/log-compressor.js

@@ -1,12 +1,12 @@
-import { estimateTokens } from '../tokens/estimate.js';
 // ponytail: heuristic line filter, not ML — O(n) scan, no deps
 const ANSI_RE = /\u001b\[[0-9;]*[a-zA-Z]/g;
 const KEEP_RE = /(FAIL|FAILED|Error|AssertionError|Exception|Traceback|panic|npm ERR!|ERR!|Expected|Received|missing|×|●|✕|FAIL:|--- FAIL|not ok|at\s+.*:\d+:\d+|stack|Caused by|test result:\s*FAILED|running \d+ test|test .* \.\.\. FAILED|BUILD FAILED|Tests run:|FAILURE:|cargo:.*error|error\[E\d+\]|thread '.*' panicked)/i;
 const PASS_RE = /^(PASS|\s*✓|\s*✔|\s*ok\s|…+\s*$|\s*\.\s*$|test result:\s*ok|running \d+ test.*ok)/i;
 const NOISE_RE = /^\s*(npm (notice|warn|info)|Browserslist|cached|Downloading|Done in|Compiling\s|cargo:.*Finished)/i;
 const STACK_RE = /^\s*(at\s+|File ".*", line \d+|#\d+\s+0x|goroutine \d+ \[|thread '.*' panicked|note: run with)/;
+const SUMMARY_RE = /(tests?\s+(passed|failed|run)|test result:|suites?\s+\d+|\d+\s+passed|BUILD (SUCCESS|FAILED)|===.*passed.*===|passed in \d+|built in|modules transformed|Finished.*release|Finished.*dev)/i;
 
-function cleanAnsi(str) {
+export function cleanAnsi(str) {
   if (!str || !str.includes('\u001b')) return str || '';
   return str.replace(ANSI_RE, '');
 }
@@ -15,8 +15,14 @@ function keepLine(clean) {
   return KEEP_RE.test(clean) || STACK_RE.test(clean);
 }
 
+function isSummaryLine(clean) {
+  return SUMMARY_RE.test(clean);
+}
+
 export function compressLog(text, { mode = 'balanced', maxLines = 400 } = {}) {
-  if (!text || typeof text !== 'string') return { compressed: '', originalTokens: 0, compressedTokens: 0, savedTokens: 0, savedPercent: 0, keptLines: 0, totalLines: 0 };
+  if (!text || typeof text !== 'string') {
+    return { compressed: '', keptLines: 0, totalLines: 0 };
+  }
   const lines = text.split(/\r?\n/);
   const totalLines = lines.length;
   if (mode === 'raw') {
@@ -27,53 +33,70 @@ export function compressLog(text, { mode = 'balanced', maxLines = 400 } = {}) {
       if (NOISE_RE.test(clean)) return false;
       return true;
     });
-    const truncated = filtered.length > maxLines ? [...filtered.slice(0, maxLines - 1), `… truncated ${filtered.length - maxLines + 1} lines`] : filtered;
+    const truncated = filtered.length > maxLines
+      ? [...filtered.slice(0, maxLines - 1), `… truncated ${filtered.length - maxLines + 1} lines`]
+      : filtered;
     const compressed = truncated.join('\n');
-    const originalTokens = estimateTokens(text);
-    const compressedTokens = estimateTokens(compressed);
-    return { compressed, originalTokens, compressedTokens, savedTokens: Math.max(0, originalTokens - compressedTokens), savedPercent: originalTokens ? Math.round((1 - compressedTokens / originalTokens) * 100) : 0, keptLines: truncated.length, totalLines };
+    return { compressed, keptLines: truncated.length, totalLines };
   }
 
   const keep = new Array(lines.length).fill(false);
   const cleanLines = new Array(lines.length);
   const context = mode === 'aggressive' ? 1 : 2;
+  let hasFailure = false;
+
   for (let i = 0; i < lines.length; i++) {
     const clean = cleanAnsi(lines[i]);
     cleanLines[i] = clean;
     if (keepLine(clean)) {
+      hasFailure = true;
       const s = Math.max(0, i - context);
       const e = Math.min(lines.length - 1, i + context);
       for (let j = s; j <= e; j++) keep[j] = true;
     }
   }
-  // if nothing matched, keep first/last few lines as hint
-  if (!keep.some(Boolean)) {
-    const head = Math.min(6, lines.length);
+
+  // If no failure was detected (e.g. successful test or build run),
+  // collapse into summary: keep first few lines and summary lines
+  if (!hasFailure) {
+    const head = Math.min(3, lines.length);
     for (let i = 0; i < head; i++) keep[i] = true;
-    if (lines.length > head) {
-      keep[lines.length - 1] = true;
+    for (let i = head; i < lines.length; i++) {
+      if (isSummaryLine(cleanLines[i])) {
+        keep[i] = true;
+      }
     }
+    if (lines.length > 0) keep[lines.length - 1] = true;
   }
-  // drop pure PASS/noise unless within keep window already marked via context
+
+  // drop pure PASS/noise unless marked
   let out = [];
-  for (let i = 0; i < lines.length; i++) if (keep[i]) {
-    const l = lines[i];
-    const clean = cleanLines[i];
-    // aggressive drops more noise even inside window
-    if (mode === 'aggressive' && (PASS_RE.test(clean) || NOISE_RE.test(clean)) && !keepLine(clean)) continue;
-    out.push(l);
+  for (let i = 0; i < lines.length; i++) {
+    if (keep[i]) {
+      const l = lines[i];
+      const clean = cleanLines[i];
+      if (mode === 'aggressive' && (PASS_RE.test(clean) || NOISE_RE.test(clean)) && !keepLine(clean) && !isSummaryLine(clean)) {
+        continue;
+      }
+      out.push(l);
+    }
   }
 
   // collapse consecutive empty lines
   const collapsed = [];
   let emptyStreak = 0;
   for (const l of out) {
-    if (l.trim() === '') { emptyStreak++; if (emptyStreak <= 1) collapsed.push(l); }
-    else { emptyStreak = 0; collapsed.push(l); }
+    if (l.trim() === '') {
+      emptyStreak++;
+      if (emptyStreak <= 1) collapsed.push(l);
+    } else {
+      emptyStreak = 0;
+      collapsed.push(l);
+    }
   }
   out = collapsed;
 
-  // deduplicate repeated progress dots lines like "................"
+  // deduplicate repeated progress dots lines like '................'
   out = out.filter((l, idx, arr) => {
     if (/^[.\s]+$/.test(l) && l.length > 20) return false;
     if (idx > 0 && l === arr[idx - 1] && l.trim() !== '') return false;
@@ -82,13 +105,15 @@ export function compressLog(text, { mode = 'balanced', maxLines = 400 } = {}) {
 
   if (out.length > maxLines) {
     const half = Math.floor((maxLines - 1) / 2);
-    out = [...out.slice(0, half), `… truncated ${out.length - maxLines + 1} lines …`, ...out.slice(out.length - half)];
+    out = [
+      ...out.slice(0, half),
+      `… truncated ${out.length - maxLines + 1} lines …`,
+      ...out.slice(out.length - half)
+    ];
   }
+
   const compressed = out.join('\n');
-  const originalTokens = estimateTokens(text);
-  const compressedTokens = estimateTokens(compressed);
-  return { compressed, originalTokens, compressedTokens, savedTokens: Math.max(0, originalTokens - compressedTokens), savedPercent: originalTokens ? Math.round((1 - compressedTokens / originalTokens) * 100) : 0, keptLines: out.length, totalLines };
+  return { compressed, keptLines: out.length, totalLines };
 }
 
-export { cleanAnsi, estimateTokens };
-export default { compressLog, cleanAnsi, estimateTokens };
+export default { compressLog, cleanAnsi };

package/lib/index.js

@@ -1,27 +1,13 @@
 import z from '@deepseek-ai/schemastery';
-import * as tracker from './tokens/tracker.js';
-import { compressLog } from './compression/log-compressor.js';
-import { writeJson, readBody, isTrustedRequest } from './http.js';
-import { registerPluginUpdater } from './updater.js';
-import {
-  renderOutput,
-  registerTools,
-  getFocus,
-  clearFocus,
-  getLastActiveSession
-} from './tools.js';
+import { renderOutput, registerTools } from './tools.js';
 
 export const name = '@goodandready/dsh-context-lens';
-export const inject = ['tools', 'settings', 'webServer'];
+export const inject = ['tools', 'settings'];
 
 export const Config = z.object({
   compressionMode: z.string().default('balanced').description('Log compression aggressiveness (raw/balanced/aggressive)'),
   astSkeletonMaxDepth: z.number().default(3).description('Max depth for AST skeleton generation'),
-  tokenSavingsTracking: z.boolean().default(true).description('Track and display token budget savings'),
-  autoCompressThreshold: z.number().default(4000).description('Auto-compress threshold in chars (0 to disable)'),
-  budgetLimit: z.number().default(100000).description('Session token budget; compressions stop counting after this limit'),
-  budgetAlertPercent: z.number().default(90).description('Budget percentage threshold (50-99%) for warning alert'),
-  autoCollapse: z.boolean().default(true).description('Warn in UI when budget is nearly exhausted (does not force-close the settings card)')
+  autoCompressThreshold: z.number().default(4000).description('Auto-compress threshold in chars for test/build logs (0 to disable)')
 });
 
 const NS = '@goodandready/dsh-context-lens';
@@ -95,157 +81,8 @@ export function apply(ctx, config) {
     }
   });
 
-  function maybeTrack(original, compressed) {
-    const cfg = getConfig();
-    if (cfg.tokenSavingsTracking === false) return;
-    tracker.record(original, compressed);
-  }
-
-  // Register AI agent tools
+  // Register consolidated AI agent tools (context_lens_code, context_lens_log)
   if (ctx.tools) {
-    registerTools(ctx, { getConfig, maybeTrack });
-  }
-
-  if (ctx.webServer) {
-    // #61: One-click plugin updater endpoint (/api/dsh-context-lens/update)
-    const mountUpdater = () => registerPluginUpdater(ctx, {
-      packageName: '@goodandready/dsh-context-lens',
-      manifestUrl: new URL('../package.json', import.meta.url),
-      endpoint: '/api/dsh-context-lens/update'
-    });
-    if (typeof ctx.effect === 'function') {
-      ctx.effect(mountUpdater, 'dsh-context-lens: updater');
-    } else {
-      mountUpdater();
-    }
-
-    // Status route (#70: explicit URL parsing and validation; #87: GET only, trusted source check)
-    ctx.effect(() => ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-context-lens/status',
-      handler: (req, res) => {
-        if (req.method !== 'GET') {
-          res.writeHead(405, { Allow: 'GET', 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ ok: false, error: 'Method Not Allowed: GET required' }));
-          return;
-        }
-        if (!isTrustedRequest(req)) {
-          writeJson(res, 403, { ok: false, error: 'Forbidden: untrusted request origin' });
-          return;
-        }
-
-        const cfg = getConfig();
-        if (typeof cfg.budgetLimit === 'number') tracker.setBudgetLimit(cfg.budgetLimit);
-        if (typeof cfg.budgetAlertPercent === 'number') tracker.setBudgetAlertPercent(cfg.budgetAlertPercent);
-        let sId = getLastActiveSession() || '__default__';
-        try {
-          const u = new URL(req.url, 'http://127.0.0.1');
-          const qId = u.searchParams.get('sessionId') || u.searchParams.get('session_id');
-          if (qId !== null) {
-            if (!qId || typeof qId !== 'string' || qId.trim() === '') {
-              writeJson(res, 400, { ok: false, error: 'Invalid sessionId parameter' });
-              return;
-            }
-            sId = qId.trim();
-          }
-        } catch (err) {
-          ctx.logger?.warn?.('dsh-context-lens: failed to parse request url in status', err);
-          writeJson(res, 400, { ok: false, error: 'Malformed request URL' });
-          return;
-        }
-
-        writeJson(res, 200, {
-          ok: true,
-          plugin: 'dsh-context-lens',
-          stats: tracker.getStats(cfg.budgetLimit, cfg.budgetAlertPercent),
-          history: tracker.getHistory(),
-          focus: getFocus(sId),
-          sessionId: sId
-        });
-      }
-    }), 'dsh-context-lens status route');
-
-    // Quick clear-focus API route (#62: POST only, trusted origin check; #70: clean URL error handling)
-    ctx.effect(() => ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-context-lens/clear-focus',
-      handler: async (req, res) => {
-        if (req.method !== 'POST') {
-          res.writeHead(405, { Allow: 'POST', 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ ok: false, error: 'Method Not Allowed: POST required' }));
-          return;
-        }
-        if (!isTrustedRequest(req)) {
-          writeJson(res, 403, { ok: false, error: 'Forbidden: untrusted request origin' });
-          return;
-        }
-
-        let sId = getLastActiveSession() || '__default__';
-        try {
-          const u = new URL(req.url, 'http://127.0.0.1');
-          const qId = u.searchParams.get('sessionId') || u.searchParams.get('session_id');
-          if (qId !== null) {
-            if (!qId || typeof qId !== 'string' || qId.trim() === '') {
-              writeJson(res, 400, { ok: false, error: 'Invalid sessionId parameter' });
-              return;
-            }
-            sId = qId.trim();
-          }
-        } catch (err) {
-          ctx.logger?.warn?.('dsh-context-lens: failed to parse request url in clear-focus', err);
-          writeJson(res, 400, { ok: false, error: 'Malformed request URL' });
-          return;
-        }
-
-        clearFocus(sId);
-        writeJson(res, 200, { ok: true, sessionId: sId, focus: getFocus(sId) });
-      }
-    }), 'dsh-context-lens clear-focus route');
-
-    // Server-backed preview (#63: POST only, trusted origin, bounded body size, clamped maxLines)
-    ctx.effect(() => ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-context-lens/compress-preview',
-      handler: async (req, res) => {
-        if (req.method !== 'POST') {
-          res.writeHead(405, { Allow: 'POST', 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ ok: false, error: 'Method Not Allowed: POST required' }));
-          return;
-        }
-        if (!isTrustedRequest(req)) {
-          writeJson(res, 403, { ok: false, error: 'Forbidden: untrusted request origin' });
-          return;
-        }
-
-        let body;
-        try {
-          const raw = await readBody(req, 256 * 1024);
-          body = JSON.parse(raw.toString('utf8') || '{}');
-        } catch (e) {
-          if (e?.message === 'body too large') {
-            writeJson(res, 413, { ok: false, error: 'Payload Too Large: maximum 256KB allowed' });
-            return;
-          }
-          writeJson(res, 400, { ok: false, error: 'Malformed JSON body' });
-          return;
-        }
-
-        let maxLines = 400;
-        if (body.maxLines !== undefined) {
-          const parsed = Number(body.maxLines);
-          if (Number.isNaN(parsed) || parsed < 1 || parsed > 5000) {
-            writeJson(res, 400, { ok: false, error: 'maxLines must be a number between 1 and 5000' });
-            return;
-          }
-          maxLines = Math.floor(parsed);
-        }
-
-        const cfg = getConfig();
-        const mode = body.mode || cfg.compressionMode || 'balanced';
-        const text = typeof body.text === 'string' ? body.text : '';
-        const out = compressLog(text, { mode, maxLines });
-        writeJson(res, 200, { ok: true, mode, ...out });
-      }
-    }), 'dsh-context-lens compress-preview route');
+    registerTools(ctx, { getConfig });
   }
 }

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.25",
-  "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"
   }
 }