@synkro-sh/cli 1.7.1 → 1.7.3

package/dist/bootstrap.js

@@ -1951,6 +1951,62 @@ export async function localGradeCwe(prompt: string, agentKind: AgentKind = 'clau
   return channelGrade('grade-cwe', prompt, jwt, 18930, timeoutMs, agentKind);
 }
 
+// \u2500\u2500\u2500 Fix-poll directive (ask-mode human-preference capture) \u2500\u2500\u2500
+// Turns an ask-mode flag into a labeled DPO pair: candidate A is the grader's
+// suggested fix; candidate B is a best-effort second grade nudged toward a
+// different technique. Registers a pending fix_labels item and returns an agent
+// directive to poll the user + call record_fix_choice. PURELY ADDITIVE \u2014 any
+// failure returns '' so enforcement behaves exactly as before.
+export async function buildFixPollDirective(o: { candA: string; code: string; ruleId: string; sessionId: string; filePath: string; model: string; graderPrompt: string; graderPool?: AgentKind }): Promise<string> {
+  try {
+    const candA = (o.candA || '').trim();
+    if (!candA) return '';
+    const cands: string[] = [candA];
+    try {
+      // Candidate B from the SAME grader that produced A (the edit/rule grader),
+      // reusing its prompt + rules \u2014 nudged toward a different remediation. Using
+      // grade-cwe here would mis-grade an org-rule violation ('no rules' / wrong
+      // surface), so we re-grade the edit surface. Best-effort: 1 candidate is fine.
+      const altPrompt = (o.graderPrompt || '') + '\\n\\n// SECURITY REVIEWER: also propose an ALTERNATIVE remediation that uses a DIFFERENT technique than the most obvious one.';
+      const rawB = await localGrade('edit', altPrompt, 12000, o.graderPool);
+      const candB = (parseVerdict(rawB).suggestedFix || '').trim();
+      if (candB && candB !== candA) cands.push(candB);
+    } catch (e) { /* best-effort: one candidate is fine */ }
+    // Route by deploy location: cloud -> the gateway (Timescale, org-scoped, auth'd);
+    // local -> the on-device server (PGLite). GATEWAY_URL is host-allowlisted; the
+    // loopback port is range-validated (CWE-918) so neither is an arbitrary host.
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    let url: string;
+    if (process.env.SYNKRO_DEPLOY_LOCATION === 'cloud') {
+      const jwt = loadJwt();
+      if (!jwt) return '';
+      headers['Authorization'] = 'Bearer ' + jwt;
+      url = GATEWAY_URL + '/api/v1/cli/fix-poll';
+    } else {
+      const rawPort = parseInt(process.env.SYNKRO_MCP_PORT || '18931', 10);
+      const mcpPort = (rawPort > 0 && rawPort < 65536) ? rawPort : 18931;
+      url = 'http://127.0.0.1:' + mcpPort + '/api/local/fix-poll';
+    }
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        session_id: o.sessionId, file_path: o.filePath, cwe: o.ruleId,
+        vulnerable_code: (o.code || '').slice(0, 8000), candidates: cands, generator_model: o.model || '',
+      }),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) return '';
+    const j = await resp.json() as { item_id?: string };
+    if (!j || !j.item_id) return '';
+    let optsStr = '';
+    for (let i = 0; i < cands.length; i++) optsStr += '\\n  [' + i + '] ' + cands[i];
+    return '\\n\\nSYNKRO FIX POLL (item_id=' + j.item_id + '): Before retrying, present these candidate fixes to the user with the AskUserQuestion tool (one option per candidate, plus a "None of the above" option), then call the record_fix_choice tool with item_id="' + j.item_id + '" and chosen_idx set to the 0-based option the user picked (-1 for none of the above). Candidates:' + optsStr;
+  } catch (e) {
+    return '';
+  }
+}
+
 // \u2500\u2500\u2500 Rule Pre-Filter (embedding-based) \u2500\u2500\u2500
 
 /** User message + action for embedding search \u2014 intent surfaces boundary/consent rules the command alone misses. */
@@ -1966,7 +2022,7 @@ export async function filterRules(commandText: string, allRules: Rule[]): Promis
   if (allRules.length <= 3) return allRules;
 
   // Cloud: the embedding index lives server-side (the container grade path can't
-  // reach 127.0.0.1), so ask the gateway for the top-3 relevant rules \u2014 same
+  // reach 127.0.0.1), so ask the gateway for the top-5 relevant rules \u2014 same
   // CF/BYOK bge-base vectors, same behavior as local. Without this, cloud grades
   // dumped EVERY rule into the prompt (9KB+), the dominant cause of grade
   // timeouts. Any failure falls back to all rules (status quo), never blocks.
@@ -1977,7 +2033,7 @@ export async function filterRules(commandText: string, allRules: Rule[]): Promis
       const resp = await fetch(GATEWAY_URL + '/api/v1/hook/filter-rules', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
-        body: JSON.stringify({ text: commandText, top_k: 3 }),
+        body: JSON.stringify({ text: commandText, top_k: 5 }),
         signal: AbortSignal.timeout(2000),
       });
       if (!resp.ok) return allRules;
@@ -1996,7 +2052,7 @@ export async function filterRules(commandText: string, allRules: Rule[]): Promis
     const resp = await fetch('http://127.0.0.1:' + mcpPort + '/api/local/filter-rules', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ text: commandText, top_k: 3 }),
+      body: JSON.stringify({ text: commandText, top_k: 5 }),
       signal: AbortSignal.timeout(500),
     });
     if (!resp.ok) return allRules;
@@ -4524,6 +4580,11 @@ async function main() {
 
     if (rt === 'local') {
       // \u2500\u2500\u2500 Local grading: org rules ONLY (channel 1, port 18929) \u2500\u2500\u2500
+      // CAP COUPLING: 4000 chars keeps the grade payload small enough to finish
+      // well inside the timing budget (hook abort 45s < channel 120s < dispatch
+      // 125s). Raising this materially grows per-grade inference time and, under
+      // concurrency, pushes the latency tail toward those ceilings \u2014 so if you
+      // raise it, revisit WORKER_DISPATCH_TIMEOUT_MS / the channel timeout first.
       const proposedShort = proposed.slice(0, 4000);
       // The TASK grade sees the DIFF for large files, so a contradiction or drift DEEP
       // in a big file is visible \u2014 the old "first 4KB of the whole file" window missed
@@ -4715,8 +4776,12 @@ async function main() {
         const mode = normalizeMode(verdict.ruleMode || ruleMode(verdict.ruleId, config.rules));
         const guardReason = (verdict.ruleId ? '(' + verdict.ruleId + ') ' : '') + (verdict.reason || 'policy violation');
 
+        // fix mode: the grader still produces a fix, but the MODEL applies it (no
+        // human poll) \u2014 surface our suggested fix so the agent picks it up rather
+        // than re-deriving. ask mode: no fix in the deny text; the poll directive
+        // (below) lets the HUMAN choose among candidates.
         const denyReason = mode === 'fix'
-          ? 'Guard: ' + guardReason + '\\nFix all issues before retrying. Do NOT ask the user to make the edit manually \u2014 resolve the violation in code yourself.'
+          ? 'Guard: ' + guardReason + (verdict.suggestedFix ? '\\nSuggested fix (apply this): ' + verdict.suggestedFix : '') + '\\nFix all issues before retrying. Do NOT ask the user to make the edit manually \u2014 resolve the violation in code yourself.'
           : 'Guard: ' + guardReason + '\\nAsk the user for explicit consent before retrying.';
         dispatchCapture(jwt, 'edit', 'block', verdict.severity || 'critical', verdict.category || 'security',
           toolName, gitRepo, sessionId, config.captureDepth, {
@@ -4724,9 +4789,17 @@ async function main() {
             rulesChecked: relevantRules, violatedRules,
             ccModel: captureModel, codeChange: editDiff, ...lineMetrics,
           });
+        // Ask-mode only: turn this flag into a human-preference label (additive; '' on any failure).
+        let pollDirective = '';
+        if (mode !== 'fix' && verdict.suggestedFix) {
+          pollDirective = await buildFixPollDirective({
+            candA: verdict.suggestedFix, code: proposed, ruleId: verdict.ruleId,
+            sessionId, filePath, model: captureModel, graderPrompt, graderPool,
+          });
+        }
         outputJson({
           systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked: ' + guardReason,
-          hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: denyReason, additionalContext: denyReason },
+          hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: denyReason, additionalContext: denyReason + pollDirective },
         });
         return;
       }
@@ -11538,7 +11611,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.7.1")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.7.3")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -15601,7 +15674,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.7.1");
+  console.log("1.7.3");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents