carrick 0.3.130 → 0.3.131

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.130",
+  "version": "0.3.131",
   "carrickCache": {
     "cache_version": 22,
     "intent_cache_version": 2
@@ -113,11 +113,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.130",
-    "@carrick-tools/cli-darwin-x64": "0.3.130",
-    "@carrick-tools/cli-linux-arm64": "0.3.130",
-    "@carrick-tools/cli-linux-x64": "0.3.130",
-    "@carrick-tools/cli-win32-x64": "0.3.130"
+    "@carrick-tools/cli-darwin-arm64": "0.3.131",
+    "@carrick-tools/cli-darwin-x64": "0.3.131",
+    "@carrick-tools/cli-linux-arm64": "0.3.131",
+    "@carrick-tools/cli-linux-x64": "0.3.131",
+    "@carrick-tools/cli-win32-x64": "0.3.131"
   },
   "devDependencies": {
     "@types/node": "^24.13.3"

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "carrick",
   "description": "Claude Code plugin for Carrick, which indexes TypeScript codebases across service and repository boundaries. After each edit it adds the file's routes, calls, and cross-service type mismatches to the session, and it registers Carrick's language server. It pairs with the Carrick MCP server, which lets agents search functions by intent rather than name.",
-  "version": "0.3.130",
+  "version": "0.3.131",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

package/sidecar/dist/src/capture/check-classify.d.ts

@@ -10,7 +10,9 @@
  *   surface import error (probe lines 1-2)-> unverifiable
  *   IsAny gate fired (TS2344)             -> gate_caught_baked_any
  *   IsUnknown/IsNever gate fired (TS2344) -> unverifiable
- *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
+ *   IsVoid gate fired (TS2344)            -> compatible with a note when the
+ *                                            consumer reads no response body;
+ *                                            else unverifiable (no body read)
  *   IsFormBody gate fired (TS2344)        -> unverifiable (form-encoded body)
  *   IsByteBody gate fired (TS2344)        -> unverifiable (bytes, even agreeing)
  *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
@@ -94,3 +96,5 @@ export declare function classifyPair(input: ClassifyInput): CheckVerdict;
  * (carrick#2011).
  */
 export declare const CONSUMER_WIDER_NOTE: string;
+/** The note on a pair whose consumer reads no response body (carrick#1162). */
+export declare const CONSUMER_READS_NO_BODY_NOTE = "the consumer reads no response body (its expected response is void), so the producer response is not compared with a read";

package/sidecar/dist/src/capture/check-classify.js

@@ -10,7 +10,9 @@
  *   surface import error (probe lines 1-2)-> unverifiable
  *   IsAny gate fired (TS2344)             -> gate_caught_baked_any
  *   IsUnknown/IsNever gate fired (TS2344) -> unverifiable
- *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
+ *   IsVoid gate fired (TS2344)            -> compatible with a note when the
+ *                                            consumer reads no response body;
+ *                                            else unverifiable (no body read)
  *   IsFormBody gate fired (TS2344)        -> unverifiable (form-encoded body)
  *   IsByteBody gate fired (TS2344)        -> unverifiable (bytes, even agreeing)
  *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
@@ -167,6 +169,21 @@ export function classifyPair(input) {
         .find((name) => name.endsWith(':void') || name.endsWith(':form'));
     if (shapeGate) {
         const { side, kind } = sideForGate(shapeGate, plan);
+        // A call site that reads no response body is compatible with whatever the
+        // producer answers: nothing it does depends on the body. Only the
+        // response direction (http, graphql), where the consumer is the expected
+        // side; a void producer, or a consumer that sends void (a request, a
+        // socket or pub/sub payload), still states no contract. The producer's
+        // own top-type gates fired above, and `factness` still reads the producer
+        // side, so a producer with an `any` inside stays not a fact.
+        if (kind === 'void' && side === 'consumer' && plan.direction.expected === 'consumer') {
+            return {
+                ...base,
+                bucket: 'compatible',
+                notes: [...base.notes, CONSUMER_READS_NO_BODY_NOTE],
+                ...factness(input),
+            };
+        }
         if (kind === 'void') {
             return {
                 ...base,
@@ -357,6 +374,8 @@ export function classifyPair(input) {
  */
 export const CONSUMER_WIDER_NOTE = "the consumer's published request type is wider than what the call sends: " +
     'it widened a literal the call writes, and the values sent fit the producer';
+/** The note on a pair whose consumer reads no response body (carrick#1162). */
+export const CONSUMER_READS_NO_BODY_NOTE = 'the consumer reads no response body (its expected response is void), so the producer response is not compared with a read';
 function onUnwidenedLines(plan, diagnostic) {
     return plan.unwidenedFromLine !== undefined && diagnostic.line >= plan.unwidenedFromLine;
 }

package/sidecar/dist/src/retype.js

@@ -195,6 +195,12 @@ export class Retyper {
             };
         }
         if (declaresTypeParameters(call)) {
+            const inferred = inferredTypeParameterOf(call);
+            if (inferred) {
+                return (`the callee declares several type parameters and '${inferred}' is ` +
+                    `inferred from the arguments, so writing one type argument would turn ` +
+                    `its inference off`);
+            }
             const open = call.getFirstChildByKind(SyntaxKind.OpenParenToken);
             if (!open)
                 return 'the consumer call has no argument list to retype';
@@ -948,6 +954,42 @@ function bodyReadEdit(read) {
         { start: end, end, text: ` as Promise<${stated}>)`, statedAt: ' as Promise<'.length },
     ];
 }
+/**
+ * The name of a type parameter after the first that the call's arguments
+ * infer and whose default would change the call if inference were off, or
+ * `undefined`.
+ *
+ * Writing one type argument makes every other parameter take its default
+ * instead of its inferred type. A parameter the argument list mentions
+ * (`TVariables` in `options: Options<TData, TError, TVariables>`) and whose
+ * default is not `any` or `unknown` then types the argument against the
+ * default (`void`), and the call reports a diagnostic about the written
+ * argument, not about anything the consumer reads. A parameter nothing in the
+ * argument list mentions, or one defaulting to `any`, is unaffected.
+ */
+function inferredTypeParameterOf(call) {
+    const declaration = resolvedDeclaration(call);
+    const typeParameters = declaration?.typeParameters;
+    if (!declaration || !typeParameters || typeParameters.length < 2)
+        return undefined;
+    for (const parameter of typeParameters.slice(1)) {
+        const fallback = parameter.default;
+        if (fallback &&
+            (fallback.kind === ts.SyntaxKind.AnyKeyword || fallback.kind === ts.SyntaxKind.UnknownKeyword)) {
+            continue;
+        }
+        const name = parameter.name.text;
+        if (declaration.parameters.some((p) => p.type && mentionsTypeName(p.type, name)))
+            return name;
+    }
+    return undefined;
+}
+function mentionsTypeName(node, name) {
+    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === name) {
+        return true;
+    }
+    return ts.forEachChild(node, (child) => (mentionsTypeName(child, name) ? true : undefined)) ?? false;
+}
 function declaresTypeParameters(call) {
     return (resolvedDeclaration(call)?.typeParameters?.length ?? 0) > 0;
 }

package/sidecar/dist/src/type-inferrer.d.ts

@@ -2530,6 +2530,13 @@ export declare class TypeInferrer {
      * then substring match (preferring containing matches).
      */
     private matchByText;
+    /**
+     * The text a locator opens with before an elision, or `undefined` when the
+     * locator has none. An elision is `...` followed only by closing brackets
+     * (`{ a: x, ... }`); `...rest` is a spread and source text. An opening too
+     * short to tell nodes apart is judged by the caller.
+     */
+    private elidedLocatorOpening;
     /**
      * What a locator's text names, read off its own parse (carrick#2056):
      *

package/sidecar/dist/src/type-inferrer.js

@@ -9309,6 +9309,26 @@ export class TypeInferrer {
         if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(normalizedTarget)) {
             return undefined;
         }
+        // A locator that elides members (`body: { a: x, ... }`) stands for the
+        // whole node it opens: the text before the elision is where the source
+        // opens. Never a node the text merely contains, which is one member of the
+        // payload it names.
+        // An opening shorter than this (`{`) names no node in particular.
+        const MIN_ELIDED_OPENING_LEN = 8;
+        const elidedOpening = this.elidedLocatorOpening(normalizedTarget);
+        if (elidedOpening !== undefined) {
+            if (elidedOpening.length < MIN_ELIDED_OPENING_LEN)
+                return undefined;
+            const opened = candidates.filter((c) => c.text.startsWith(elidedOpening));
+            if (opened.length === 0)
+                return undefined;
+            if (lineNumber !== undefined) {
+                const distance = (c) => Math.abs(startLineOf(c.node) - lineNumber);
+                const nearest = Math.min(...opened.map(distance));
+                return this.pickBestMatch(opened.filter((c) => distance(c) === nearest).map((c) => c.node), lineNumber);
+            }
+            return this.pickBestMatch(opened.map((c) => c.node), lineNumber);
+        }
         // Fall back to substring match
         // For the reverse direction (target contains node text), require a minimum node text
         // length to avoid matching tiny identifiers like "res" or "body" too broadly.
@@ -9375,6 +9395,18 @@ export class TypeInferrer {
         }
         return bound.size > 0 ? this.pickBestMatch([...bound], lineNumber) : undefined;
     }
+    /**
+     * The text a locator opens with before an elision, or `undefined` when the
+     * locator has none. An elision is `...` followed only by closing brackets
+     * (`{ a: x, ... }`); `...rest` is a spread and source text. An opening too
+     * short to tell nodes apart is judged by the caller.
+     */
+    elidedLocatorOpening(normalizedTarget) {
+        const match = /^(.*?)[\s,]*\.\.\.[\s,)}\]]*$/s.exec(normalizedTarget);
+        if (!match)
+            return undefined;
+        return match[1];
+    }
     /**
      * What a locator's text names, read off its own parse (carrick#2056):
      *