trimprompt 1.0.2 → 1.0.3

package/client/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "trimprompt",
+  "version": "1.0.2",
+  "description": "TrimPrompt.ai Client CLI & Local Developer Dashboard",
+  "main": "dist/cli.js",
+  "bin": {
+    "trim": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').copyFileSync('src/index.html', 'dist/index.html')\"",
+    "seed": "node dist/seed.js",
+    "simulate": "node dist/simulate.js",
+    "prepare-publish": "node obfuscate.js"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "express": "^4.18.2",
+    "open": "^8.4.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/client/src/cli.ts

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { executeCommand } from './executor';
+import { compressOutput, rewriteCommand } from './filters';
+import { tracker } from './tracker';
+import { installShims, uninstallShims } from './shims';
+import { startDashboard } from './dashboard';
+
+const program = new Command();
+
+// Helper to determine if we should bypass TrimPrompt
+function isDisabled(): boolean {
+  return process.env.TRIMPROMPT_DISABLED === '1';
+}
+
+/**
+ * Adjusts arguments for specific commands before executing them in the subprocess.
+ */
+function adjustCommandArgs(cmd: string, args: string[]): { cmd: string; args: string[] } {
+  const cmdLower = cmd.toLowerCase();
+
+  if (cmdLower === 'git' || cmdLower === 'yadm') {
+    const sub = args[0];
+    if (sub === 'status') {
+      // Check if status arguments are short-compatible
+      const statusArgs = args.slice(1);
+      const isCompatible = statusArgs.length === 0 || statusArgs.every(arg => {
+        return arg === '-b' || arg === '--branch' || arg === '-sb' || arg === '-bs' || arg === '-s' || arg === '--short';
+      });
+
+      if (isCompatible) {
+        return { cmd, args: ['status', '--porcelain', '-b'] };
+      }
+    } else if (sub === 'log') {
+      const logArgs = args.slice(1);
+      const hasFormat = logArgs.some(arg => arg.startsWith('--oneline') || arg.startsWith('--pretty') || arg.startsWith('--format'));
+      const hasLimit = logArgs.some(arg => (arg.startsWith('-') && /^\d+$/.test(arg.slice(1))) || arg === '-n' || arg.startsWith('--max-count'));
+      
+      const newArgs = [...args];
+      
+      if (!hasFormat) {
+        const formatStr = '--pretty=format:%h %s (%ar) (%an)%n%b%n---END---';
+        newArgs.push(process.platform === 'win32' ? `"${formatStr}"` : formatStr);
+      }
+
+      if (!hasLimit) {
+        if (hasFormat) {
+          newArgs.push('-50');
+        } else {
+          newArgs.push('-10');
+        }
+      }
+
+      // Filter out merges if not requested
+      const hasMergeFlag = logArgs.some(arg => arg === '--merges' || arg === '--no-merges' || arg.startsWith('--min-parents'));
+      if (!hasMergeFlag && !hasLimit) {
+        newArgs.push('--no-merges');
+      }
+
+      return { cmd, args: newArgs };
+    }
+  }
+
+  return { cmd, args };
+}
+
+function isMcpServerExecution(cmd: string, args: string[]): boolean {
+  const cmdLower = cmd.toLowerCase();
+  const argsString = args.join(' ').toLowerCase();
+
+  if (cmdLower.includes('mcp') && (cmdLower.includes('server') || cmdLower.includes('proxy'))) {
+    return true;
+  }
+
+  if (cmdLower === 'npx' || cmdLower === 'node' || cmdLower === 'bun' || cmdLower === 'npm' || cmdLower === 'pnpm' || cmdLower === 'yarn') {
+    if (argsString.includes('@modelcontextprotocol/') || argsString.includes('modelcontextprotocol') || argsString.includes('mcp-server') || argsString.includes('server-mcp')) {
+      return true;
+    }
+  }
+
+  if (args.some(arg => {
+    const l = arg.toLowerCase();
+    return l.includes('mcp-server') || l.includes('server-mcp') || l.includes('@modelcontextprotocol/') || l === 'mcp-proxy' || l === 'mcp';
+  })) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Proxy execution: runs target command, compresses output, logs metrics, and prints results.
+ */
+async function runProxy(args: string[]) {
+  if (args.length === 0) {
+    program.help();
+    return;
+  }
+
+  const rawCmd = args[0];
+  const rawArgs = args.slice(1);
+  const commandLine = args.join(' ');
+
+  if (isDisabled()) {
+    // Transparent bypass: run target command raw and exit
+    const result = await executeCommand(rawCmd, rawArgs);
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exit(result.exitCode);
+  }
+
+  // Autodetect Model Context Protocol (MCP) server execution to run streaming proxy
+  if (isMcpServerExecution(rawCmd, rawArgs)) {
+    console.error('[TrimPrompt] Autodetected MCP server execution. Activating real-time JSON-RPC proxy...');
+    const { runMcpProxy } = await import('./mcp');
+    runMcpProxy(rawCmd, rawArgs);
+    return;
+  }
+
+  // Adjust arguments if needed (e.g. inject porcelain flags for git status)
+  const adjusted = adjustCommandArgs(rawCmd, rawArgs);
+
+  // Execute the target subprocess
+  const result = await executeCommand(adjusted.cmd, adjusted.args);
+
+  // Compress stdout/stderr
+  const compressed = compressOutput(
+    commandLine, 
+    result.stdout, 
+    result.stderr, 
+    tracker.getConfig().redaction_enabled
+  );
+
+  // Log execution locally
+  const combinedRaw = result.stdout + (result.stderr.trim().length > 0 ? '\n' + result.stderr : '');
+  tracker.logExecution(commandLine, combinedRaw, compressed, result.exitCode);
+
+  // Print outputs
+  if (result.exitCode === 0) {
+    process.stdout.write(compressed + '\n');
+  } else {
+    // If command failed, print compressed results plus original stderr to help debugging
+    process.stdout.write(compressed + '\n');
+    if (result.stderr.trim().length > 0 && !compressed.includes(result.stderr.trim())) {
+      process.stderr.write(result.stderr + '\n');
+    }
+  }
+
+  process.exit(result.exitCode);
+}
+
+// Register CLI commands
+program
+  .name('trim')
+  .description('TrimPrompt.ai - Reduce LLM token consumption by 60-90%')
+  .version('1.0.0');
+
+program
+  .command('ui')
+  .alias('dashboard')
+  .description('Start the local developer dashboard')
+  .option('-p, --port <number>', 'Port to run the dashboard on', '4000')
+  .action((options) => {
+    const port = parseInt(options.port, 10);
+    startDashboard(port);
+  });
+
+program
+  .command('stats')
+  .description('Show token and cost savings summary')
+  .option('-m, --model <string>', 'Select pricing model (e.g. claude-3-5-sonnet, gpt-4o)', 'claude-3-5-sonnet')
+  .action((options) => {
+    const summary = tracker.getStatsSummary(options.model);
+    console.log('\n=============================================');
+    console.log('       TRIMPROMPT.AI SAVINGS SUMMARY        ');
+    console.log('=============================================');
+    console.log(`Model Context:     ${summary.model_name}`);
+    console.log(`Raw Tokens:        ${summary.total_raw_tokens.toLocaleString()}`);
+    console.log(`Compressed:        ${summary.total_compressed_tokens.toLocaleString()}`);
+    console.log(`Tokens Saved:      ${summary.total_tokens_saved.toLocaleString()}`);
+    console.log(`Reduction Rate:    ${summary.savings_percentage}%`);
+    console.log(`Estimated Cost:    $${summary.raw_cost_usd.toFixed(4)} (before Shave)`);
+    console.log(`Actual Cost:       $${summary.compressed_cost_usd.toFixed(4)} (after Shave)`);
+    console.log(`---------------------------------------------`);
+    console.log(`Money Saved:       $${summary.money_saved_usd.toFixed(4)} USD`);
+    console.log('=============================================\n');
+  });
+
+program
+  .command('config')
+  .description('Manage local configuration parameters')
+  .argument('<action>', 'get or set')
+  .argument('<key>', 'config parameter name')
+  .argument('[value]', 'value to set')
+  .action((action, key, value) => {
+    if (action === 'get') {
+      const config = tracker.getConfig();
+      console.log(`${key}: ${(config as any)[key]}`);
+    } else if (action === 'set') {
+      if (value === undefined) {
+        console.error('Error: Value required for set action');
+        process.exit(1);
+      }
+      let parsedValue: any = value;
+      if (value === 'true') parsedValue = true;
+      if (value === 'false') parsedValue = false;
+      if (/^\d+$/.test(value)) parsedValue = parseInt(value, 10);
+      
+      tracker.setConfig(key as any, parsedValue);
+      console.log(`Config set ${key} = ${value}`);
+    } else {
+      console.error('Error: Action must be get or set');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('shims')
+  .description('Install or uninstall system command shims')
+  .argument('<action>', 'install or uninstall')
+  .action((action) => {
+    if (action === 'install') {
+      const result = installShims();
+      console.log(result.message);
+    } else if (action === 'uninstall') {
+      const result = uninstallShims();
+      console.log(result.message);
+    } else {
+      console.error('Error: Action must be install or uninstall');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('rewrite')
+  .description('Check a command line and return the optimized command line')
+  .argument('<commandLine>', 'Command line to evaluate')
+  .action((commandLine) => {
+    if (isDisabled()) {
+      console.log(commandLine);
+      return;
+    }
+    const rewritten = rewriteCommand(commandLine);
+    console.log(rewritten);
+  });
+
+program
+  .command('mcp-proxy')
+  .alias('mcp')
+  .description('Proxy wrapper for Model Context Protocol (MCP) servers to compact tool outputs')
+  .argument('<server-command>', 'Command to launch the target MCP server')
+  .argument('[server-args...]', 'Arguments for the target MCP server')
+  .action(async (serverCmd, serverArgs) => {
+    const { runMcpProxy } = await import('./mcp');
+    runMcpProxy(serverCmd, serverArgs);
+  });
+
+// Run parser
+const args = process.argv.slice(2);
+const firstArg = args[0];
+const subcommands = ['ui', 'dashboard', 'stats', 'config', 'shims', 'rewrite', 'mcp-proxy', 'mcp', 'help', '--help', '-h', 'version', '--version', '-v'];
+
+if (firstArg && !subcommands.includes(firstArg)) {
+  // Execute wildcard command wrapper
+  runProxy(args).catch(err => {
+    console.error(`[TrimPrompt] Fatal Proxy Error: ${err.message}`);
+    process.exit(1);
+  });
+} else {
+  // Execute standard subcommand parser
+  program.parse(process.argv);
+}

package/client/src/dashboard.ts

@@ -0,0 +1,85 @@
+import express from 'express';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import open from 'open';
+import { tracker } from './tracker';
+
+const app = express();
+const baseDir = path.join(os.homedir(), '.trimprompt');
+const logsDir = path.join(baseDir, 'logs');
+
+// Serve static HTML frontend
+app.get('/', (req, res) => {
+  const htmlPath = path.join(__dirname, 'index.html');
+  if (fs.existsSync(htmlPath)) {
+    res.sendFile(htmlPath);
+  } else {
+    // Development fallback
+    res.sendFile(path.join(__dirname, '../src/index.html'));
+  }
+});
+
+// GET summary metrics
+app.get('/api/stats/summary', (req, res) => {
+  const model = (req.query.model as string) || 'auto';
+  const summary = tracker.getStatsSummary(model);
+  res.json(summary);
+});
+
+// GET execution history logs
+app.get('/api/stats/history', (req, res) => {
+  const logs = tracker.getLogs();
+  res.json(logs);
+});
+
+// GET raw vs compressed diff outputs for a specific execution ID
+app.get('/api/stats/inspect/:id', (req, res) => {
+  const logId = req.params.id;
+  const rawPath = path.join(logsDir, `${logId}.raw.txt`);
+  const compPath = path.join(logsDir, `${logId}.comp.txt`);
+
+  let raw = 'Raw output log file not found.';
+  let compressed = 'Compressed output log file not found.';
+
+  try {
+    if (fs.existsSync(rawPath)) {
+      raw = fs.readFileSync(rawPath, 'utf8');
+    }
+    if (fs.existsSync(compPath)) {
+      compressed = fs.readFileSync(compPath, 'utf8');
+    }
+  } catch (err) {
+    // Ignore read errors
+  }
+
+  res.json({ id: logId, raw, compressed });
+});
+
+/**
+ * Attempts to start the dashboard web server on the specified port.
+ * If the port is in use, it increments and tries again in a loop.
+ */
+export function startDashboard(startPort: number = 4000) {
+  let port = startPort;
+  
+  const server = app.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log(`\n[TrimPrompt] Dashboard server started at: ${url}`);
+    console.log(`Press Ctrl+C in this terminal to shut down.`);
+    
+    // Automatically open browser
+    open(url).catch(() => {
+      // Ignore open browser errors (e.g. headless machines)
+    });
+  });
+
+  server.on('error', (err: any) => {
+    if (err.code === 'EADDRINUSE') {
+      // Port in use, retry next port
+      startDashboard(port + 1);
+    } else {
+      console.error(`[TrimPrompt] Dashboard error: ${err.message}`);
+    }
+  });
+}

package/client/src/executor.ts

@@ -0,0 +1,65 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface CommandResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ * Spawns a child process, executes the command, captures output, and forwards stdin.
+ */
+export function executeCommand(
+  cmdName: string,
+  args: string[]
+): Promise<CommandResult> {
+  return new Promise((resolve) => {
+    const shimsDir = path.join(os.homedir(), '.trimprompt', 'shims');
+    const cleanPath = (process.env.PATH || '')
+      .split(path.delimiter)
+      .filter((p) => p.trim().toLowerCase() !== shimsDir.toLowerCase())
+      .join(path.delimiter);
+
+    const childEnv = {
+      ...process.env,
+      PATH: cleanPath,
+      TRIMPROMPT_DISABLED: '1'
+    };
+
+    // Spawn the command. Inherit stdin for interactive inputs (credentials, prompt confirms)
+    const child = spawn(cmdName, args, {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      shell: true, // Required on Windows to resolve shell builtins and paths correctly
+      env: childEnv
+    });
+
+    let stdoutData = '';
+    let stderrData = '';
+
+    child.stdout?.on('data', (data) => {
+      stdoutData += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderrData += data.toString();
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        exitCode: 1,
+        stdout: '',
+        stderr: `Failed to spawn command "${cmdName}": ${err.message}`
+      });
+    });
+
+    child.on('close', (code) => {
+      resolve({
+        exitCode: code ?? 0,
+        stdout: stdoutData,
+        stderr: stderrData
+      });
+    });
+  });
+}

package/client/src/filters/generic.ts

@@ -0,0 +1,60 @@
+export function stripAnsi(text: string): string {
+  const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+  return text.replace(ansiRegex, '');
+}
+
+export function collapseDuplicates(text: string): string {
+  const lines = text.split('\n');
+  if (lines.length <= 1) return text;
+
+  const result: string[] = [];
+  let currentLine = lines[0];
+  let repeatCount = 1;
+
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === currentLine && line.trim().length > 0) {
+      repeatCount++;
+    } else {
+      if (repeatCount > 1) {
+        result.push(`${currentLine} [x${repeatCount}]`);
+      } else {
+        result.push(currentLine);
+      }
+      currentLine = line;
+      repeatCount = 1;
+    }
+  }
+
+  // Last line
+  if (repeatCount > 1) {
+    result.push(`${currentLine} [x${repeatCount}]`);
+  } else {
+    result.push(currentLine);
+  }
+
+  return result.join('\n');
+}
+
+export function softTruncate(text: string, maxChars: number = 20000): string {
+  if (text.length <= maxChars) return text;
+
+  const lines = text.split('\n');
+  if (lines.length <= 200) {
+    return text; // Don't truncate if line count is small
+  }
+
+  const firstCount = 50;
+  const lastCount = 150;
+
+  const firstLines = lines.slice(0, firstCount);
+  const lastLines = lines.slice(lines.length - lastCount);
+
+  const truncatedCount = text.length - (firstLines.join('\n').length + lastLines.join('\n').length);
+
+  return [
+    ...firstLines,
+    `\n... [TrimPrompt: Truncated ${truncatedCount} characters of output] ...\n`,
+    ...lastLines
+  ].join('\n');
+}

package/client/src/filters/git.ts

@@ -0,0 +1,150 @@
+import * as path from 'path';
+
+/**
+ * Custom Git Status Compressor.
+ * Rewrites branch headers, groups modifications, and collapses large directories of untracked files.
+ */
+export function filterGitStatus(stdout: string): string {
+  const lines = stdout.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+  if (lines.length === 0) {
+    return "Clean working tree";
+  }
+
+  const result: string[] = [];
+  const untrackedFiles: string[] = [];
+  const modifiedFiles: string[] = [];
+
+  // Parse branch line and other modifications
+  for (const line of lines) {
+    if (line.startsWith('##')) {
+      const branchName = line.replace(/^##\s*/, '');
+      result.push(`* Branch: ${branchName}`);
+    } else if (line.startsWith('??')) {
+      untrackedFiles.push(line.substring(3).trim());
+    } else {
+      modifiedFiles.push(line);
+    }
+  }
+
+  // Output modified files as-is
+  if (modifiedFiles.length > 0) {
+    result.push("\nChanges:");
+    result.push(...modifiedFiles.map(f => `  ${f}`));
+  }
+
+  // Group untracked files by directory to prevent token bloat
+  if (untrackedFiles.length > 0) {
+    result.push("\nUntracked files:");
+    const dirGroups: Record<string, string[]> = {};
+    const rootFiles: string[] = [];
+
+    for (const file of untrackedFiles) {
+      const dir = path.dirname(file);
+      if (dir === '.' || dir === '') {
+        rootFiles.push(file);
+      } else {
+        if (!dirGroups[dir]) {
+          dirGroups[dir] = [];
+        }
+        dirGroups[dir].push(path.basename(file));
+      }
+    }
+
+    // List grouped directories
+    for (const [dir, files] of Object.entries(dirGroups)) {
+      if (files.length > 5) {
+        result.push(`  ?? ${dir}/ (${files.length} untracked files)`);
+      } else {
+        for (const file of files) {
+          result.push(`  ?? ${path.join(dir, file)}`);
+        }
+      }
+    }
+
+    // List root files
+    for (const file of rootFiles) {
+      result.push(`  ?? ${file}`);
+    }
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * Custom Git Log Formatting.
+ * Simplifies commit logs, formats hashes and relative dates, and displays commit bodies neatly.
+ */
+export function filterGitLog(stdout: string): string {
+  const commits = stdout.split('---END---').map(c => c.trim()).filter(c => c.length > 0);
+  if (commits.length === 0) return stdout;
+
+  const result: string[] = [];
+  for (const commit of commits) {
+    const lines = commit.split('\n');
+    const header = lines[0] || ""; // Format: hash subject (relative) <author>
+    const bodyLines = lines.slice(1).map(l => l.trim()).filter(l => l.length > 0);
+
+    result.push(`- ${header}`);
+    if (bodyLines.length > 0) {
+      // Print first line of commit body as secondary context
+      result.push(`  ${bodyLines[0]}`);
+      if (bodyLines.length > 1) {
+        result.push(`  ... (+${bodyLines.length - 1} lines of description)`);
+      }
+    }
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * Custom Unified Diff Condenser (Clean-room implementation).
+ * Strips metadata, shows summaries, and limits changes to 10 lines per file.
+ */
+export function filterGitDiff(stdout: string): string {
+  const lines = stdout.split('\n');
+  const result: string[] = [];
+
+  let currentFile = "";
+  let addedCount = 0;
+  let removedCount = 0;
+  let changes: string[] = [];
+
+  const flushFileDiff = () => {
+    if (currentFile && (addedCount > 0 || removedCount > 0)) {
+      result.push(`[file] ${currentFile} (+${addedCount} -${removedCount})`);
+      const limit = 10;
+      const printedChanges = changes.slice(0, limit);
+      for (const change of printedChanges) {
+        result.push(`  ${change}`);
+      }
+      const remaining = (addedCount + removedCount) - limit;
+      if (remaining > 0) {
+        result.push(`  ... +${remaining} more modifications`);
+      }
+    }
+    addedCount = 0;
+    removedCount = 0;
+    changes = [];
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git')) {
+      flushFileDiff();
+      // Extract file path from "diff --git a/src/index.ts b/src/index.ts"
+      const match = line.match(/\sb\/(.+)$/);
+      currentFile = match ? match[1] : "unknown_file";
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      addedCount++;
+      changes.push(line);
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      removedCount++;
+      changes.push(line);
+    }
+  }
+
+  flushFileDiff(); // Flush final file
+
+  const output = result.join('\n');
+  return output.length > 0 ? output : "No modifications";
+}