troxy-cli 1.29.16 → 1.29.18

package/bin/troxy.js

@@ -127,6 +127,39 @@ switch (command) {
     process.exit(1);
   }
 
+  // ── Token-efficiency instructions in AGENTS.md / global CLAUDE.md ──────
+  // --project scopes enable/disable/status to just this directory's
+  // AGENTS.md; default (no flag) is the global ~/.claude/CLAUDE.md, matching
+  // what the init/update prompt now recommends by default.
+  case 'concise': {
+    const {
+      maybeEnableConciseInstructions, removeConciseInstructions, conciseInstructionsConfigured,
+      enableGlobalConciseInstructions, removeGlobalConciseInstructions, globalConciseConfigured,
+    } = await import('../src/init.js');
+    const dir = process.cwd();
+    const projectOnly = Boolean(flags.project);
+
+    if (sub === 'enable') {
+      if (projectOnly) { await maybeEnableConciseInstructions('project', dir); }
+      else { console.log(`\n  Added token-efficiency instructions to ${enableGlobalConciseInstructions()} (all projects)\n`); }
+      break;
+    }
+    if (sub === 'disable') {
+      const removed = projectOnly ? removeConciseInstructions(dir) : removeGlobalConciseInstructions();
+      console.log(removed ? '\n  Removed ✓\n' : `\n  Not enabled ${projectOnly ? 'in this project' : 'globally'}.\n`);
+      break;
+    }
+    if (sub === 'status' || !sub) {
+      console.log('');
+      console.log(`  Global (~/.claude/CLAUDE.md): ${globalConciseConfigured() ? 'enabled' : 'not enabled'}`);
+      console.log(`  This project (./AGENTS.md):   ${conciseInstructionsConfigured(dir) ? 'enabled' : 'not enabled'}`);
+      console.log('');
+      break;
+    }
+    console.error(`  Unknown: troxy concise ${sub}. Try: status, enable, disable (add --project to scope to this directory)\n`);
+    process.exit(1);
+  }
+
   // ── Auth ──────────────────────────────────────────────────────
   case 'login':
     await runLogin(flags);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.16",
+  "version": "1.29.18",
   "description": "A secure control layer for AI agents: policies across payments, messages, logins, destructive actions, model usage, and secrets, all enforceable from the CLI",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/init.js

@@ -81,7 +81,7 @@ export async function refreshHostedInstructions(key) {
   return true;
 }
 
-export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null) {
+export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null, conciseOptIn = null) {
   const platform = process.platform;
   const { detected, hasOpenClaw, hasClaude, none } = detectMcpClients();
 
@@ -163,6 +163,13 @@ export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null)
     console.log('\n  Restart your MCP client to activate Troxy.');
   }
 
+  // Own opt-in, outside the client-detection if/else above: AGENTS.md is a
+  // cross-tool convention, not tied to which specific MCP client got patched.
+  // Idempotent (conciseInstructionsConfigured short-circuits), so it's safe
+  // to run on every reprovision - fresh init AND `troxy update`/rotate-key -
+  // not just the first-ever connect, without re-prompting once it's set.
+  await maybeEnableConciseInstructions(conciseOptIn, process.cwd());
+
   console.log('\n  Setting up background service...');
   const viaEphemeralNpx = ranViaEphemeralNpx();
   try {
@@ -195,6 +202,23 @@ export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null)
 const AGENTS_START = '<!-- troxy:start -->';
 const AGENTS_END   = '<!-- troxy:end -->';
 
+// A separate marker pair, not a section inside AGENTS_START/END: the security
+// checkpoint block above is load-bearing (Troxy doesn't function without it)
+// and always written. Concise instructions are a style preference the user
+// opts into separately - same file, independently addable/removable without
+// touching or re-flowing the checkpoint block.
+const CONCISE_START = '<!-- troxy:concise:start -->';
+const CONCISE_END   = '<!-- troxy:concise:end -->';
+
+const CONCISE_INSTRUCTIONS = `## Style (via Troxy)
+
+- Read existing files before writing. Don't re-read unless changed.
+- Thorough in reasoning, concise in output.
+- Skip files over 100KB unless required.
+- No sycophantic openers or closing fluff.
+- No emojis or em-dashes.
+- Do not guess APIs, versions, flags, commit SHAs, or package names. Verify by reading code or docs before asserting.`;
+
 // The endpoint deliberately does not echo the caller's key back, so the live
 // key is substituted here, on the machine that already has it. Split/join
 // rather than a regex because a key is user-controlled input and would other-
@@ -240,29 +264,122 @@ async function printHostedAgentSetup(key) {
   console.log('  Then follow it before you pay, email, log in, or delete anything.\n');
 }
 
-// Idempotent, and never clobbers instructions the user wrote themselves: the
-// Troxy section lives between markers, so re-running init (or rotate-key, which
-// changes the key inside the block) replaces only that span.
-export function writeAgentsFile(dir, text) {
-  const file = path.join(dir, 'AGENTS.md');
-  const block = `${AGENTS_START}\n${text}\n${AGENTS_END}`;
+// Claude Code's real, documented global instructions file - not the same
+// thing as a bare ~/AGENTS.md, which (per our own testing) a project working
+// directory does not walk up to. This is the one path that actually applies
+// everywhere, so it's the file the "all projects" option below writes to.
+function globalClaudeMdPath() {
+  return path.join(os.homedir(), '.claude', 'CLAUDE.md');
+}
+
+// Same merge algorithm as writeAgentsFile (marker-delimited, never clobbers
+// content outside its own span), generalized to any file path so both the
+// per-project AGENTS.md and the global CLAUDE.md can share it.
+function writeMarkedBlock(file, text, startMarker, endMarker) {
+  const block = `${startMarker}\n${text}\n${endMarker}`;
   let existing = '';
   try { existing = fs.readFileSync(file, 'utf8'); } catch {}
 
   let next;
-  if (existing.includes(AGENTS_START) && existing.includes(AGENTS_END)) {
-    const head = existing.slice(0, existing.indexOf(AGENTS_START));
-    const tail = existing.slice(existing.indexOf(AGENTS_END) + AGENTS_END.length);
+  if (existing.includes(startMarker) && existing.includes(endMarker)) {
+    const head = existing.slice(0, existing.indexOf(startMarker));
+    const tail = existing.slice(existing.indexOf(endMarker) + endMarker.length);
     next = head + block + tail;
   } else if (existing.trim()) {
     next = existing.replace(/\s*$/, '') + '\n\n' + block + '\n';
   } else {
     next = block + '\n';
   }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, next);
   return file;
 }
 
+function removeMarkedBlock(file, startMarker, endMarker) {
+  let existing;
+  try { existing = fs.readFileSync(file, 'utf8'); } catch { return false; }
+  if (!existing.includes(startMarker) || !existing.includes(endMarker)) return false;
+  const head = existing.slice(0, existing.indexOf(startMarker));
+  const tail = existing.slice(existing.indexOf(endMarker) + endMarker.length);
+  fs.writeFileSync(file, (head + tail).replace(/\n{3,}/g, '\n\n'));
+  return true;
+}
+
+function hasMarkedBlock(file, startMarker, endMarker) {
+  try {
+    const text = fs.readFileSync(file, 'utf8');
+    return text.includes(startMarker) && text.includes(endMarker);
+  } catch { return false; }
+}
+
+// Idempotent, and never clobbers instructions the user wrote themselves: the
+// Troxy section lives between markers, so re-running init (or rotate-key,
+// which changes the key inside the block) replaces only that span. Each
+// marker pair is independent - writing/removing one never touches another's
+// span or anything the user wrote outside all of them.
+export function writeAgentsFile(dir, text, startMarker = AGENTS_START, endMarker = AGENTS_END) {
+  return writeMarkedBlock(path.join(dir, 'AGENTS.md'), text, startMarker, endMarker);
+}
+
+export function conciseInstructionsConfigured(dir) {
+  return hasMarkedBlock(path.join(dir, 'AGENTS.md'), CONCISE_START, CONCISE_END);
+}
+
+export function removeConciseInstructions(dir) {
+  return removeMarkedBlock(path.join(dir, 'AGENTS.md'), CONCISE_START, CONCISE_END);
+}
+
+export function globalConciseConfigured() {
+  return hasMarkedBlock(globalClaudeMdPath(), CONCISE_START, CONCISE_END);
+}
+
+export function removeGlobalConciseInstructions() {
+  return removeMarkedBlock(globalClaudeMdPath(), CONCISE_START, CONCISE_END);
+}
+
+export function enableGlobalConciseInstructions() {
+  return writeMarkedBlock(globalClaudeMdPath(), CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
+}
+
+// conciseOptIn is one of: 'global', 'project', false (explicitly skip), or
+// null (ask interactively). Global first, and recommended by default in the
+// prompt: it's the one location Claude Code always reads regardless of which
+// directory you're in, so it structurally can't land in the wrong place the
+// way the project-scoped option did on its first real run. Never claims a
+// specific percentage in the copy below - the one number we measured for
+// this came from a flawed test (subagents don't reliably load these files
+// the way a real session does) and shouldn't be repeated as fact.
+export async function maybeEnableConciseInstructions(conciseOptIn, dir) {
+  if (globalConciseConfigured() || conciseInstructionsConfigured(dir)) return;
+
+  let choice;
+  if (conciseOptIn === 'global' || conciseOptIn === 'project' || conciseOptIn === false) {
+    choice = conciseOptIn;
+  } else if (!process.stdin.isTTY) {
+    choice = false;
+  } else {
+    console.log('\n  Add token-efficiency instructions to make Claude Code\'s responses');
+    console.log('  more concise? Trade-off: less verbose can mean less detail.');
+    console.log('');
+    console.log('    [G] All projects (recommended) - writes once to ~/.claude/CLAUDE.md');
+    console.log('    [P] This project only          - writes to ./AGENTS.md');
+    console.log('    [N] Skip');
+    console.log('');
+    console.log('  Remove any time with: troxy concise disable (add --project for just this one)');
+    const ans = (await prompt('  Choice (G/p/n): ')).toLowerCase();
+    choice = ans === 'p' ? 'project' : ans === 'n' ? false : 'global';
+  }
+
+  if (choice === false) return;
+  if (choice === 'global') {
+    const file = enableGlobalConciseInstructions();
+    console.log(`  Added token-efficiency instructions to ${file} (all projects)`);
+  } else {
+    const file = writeAgentsFile(dir, CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
+    console.log(`  Added token-efficiency instructions to ${file} (this project)`);
+  }
+}
+
 export function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
@@ -317,10 +434,20 @@ const MCP_CLIENTS = [
   },
 ];
 
-export async function runInit({ key, name, proxy } = {}) {
+export async function runInit({ key, name, proxy, concise } = {}) {
   // undefined (flag never passed) -> null, so reprovisionKeyConsumers can
   // tell "not decided, ask interactively" apart from an explicit --proxy.
   const proxyOptIn = proxy === undefined ? null : Boolean(proxy);
+  // Same null-means-ask-interactively shape as proxyOptIn, but three-valued:
+  // --concise alone (bare flag, parses as boolean true) means the
+  // recommended default, 'global'; --concise project or --concise global
+  // pick explicitly; --concise false skips. Omit the flag entirely for the
+  // default (interactive ask, or off when non-interactive).
+  const conciseOptIn =
+    concise === undefined ? null :
+    concise === true ? 'global' :
+    concise === 'false' ? false :
+    concise;
   if (!key || !key.startsWith('txy-')) {
     console.error('\n  Error: --key is required and must start with txy-');
     console.error('  Usage: npx troxy-cli init --key txy-...\n');
@@ -381,7 +508,7 @@ export async function runInit({ key, name, proxy } = {}) {
     // Non-fatal: the daemon's own heartbeat will retry this later.
   }
 
-  await reprovisionKeyConsumers(key, agentName, proxyOptIn);
+  await reprovisionKeyConsumers(key, agentName, proxyOptIn, conciseOptIn);
 
   // Scan for local AI coding tools so the dashboard's "My AI tools" view has
   // something to show. Non-fatal - a scan failure never breaks setup.

package/src/tests/tool_detect.test.js

@@ -269,7 +269,7 @@ describe('wiring: api.js / bin/troxy.js / init.js', () => {
   });
 
   it('runInit calls tool detection after reprovisionKeyConsumers, wrapped so a scan failure never blocks init', () => {
-    const reprovisionIdx = initSrc.indexOf('reprovisionKeyConsumers(key, agentName, proxyOptIn)');
+    const reprovisionIdx = initSrc.indexOf('reprovisionKeyConsumers(key, agentName, proxyOptIn, conciseOptIn)');
     const toolIdx = initSrc.indexOf('runToolDetection');
     assert.ok(reprovisionIdx !== -1, 'reprovisionKeyConsumers call not found in init.js');
     assert.ok(toolIdx !== -1, 'runToolDetection not wired into runInit');