carrick 0.3.82 → 0.3.83

package/dist/init/workspace-file.js

@@ -0,0 +1,173 @@
+// The repo selection, written where every later command reads it.
+//
+// `carrick init` asks which repos in a folder this install covers
+// (carrick#1338). The answer used to last exactly as long as the run: the
+// proposal, the project and the connection were scoped to it, and then
+// `carrick refresh`, `carrick index`, the editor hooks and the next `init` all
+// went back to deriving every repo in the folder. So a repo somebody had said
+// no to was scanned by the command that ran after the one they said it in
+// (carrick#1344).
+//
+// `carrick-workspace.json` is where that answer belongs. The scanner already
+// reads it (`src/local_mode/workspace.rs`): `exclude` names directories to
+// leave out, `Workspace::load` honours it, and the read path behind
+// `carrick check` asks the same question of the same file, so the folder's
+// hooks stop answering for a repo that is not covered. It sits in the folder
+// holding the repos, which is not itself a repository, so nothing tracked is
+// touched.
+//
+// What this file adds is the record of who wrote what. The list is shared: a
+// user can exclude a repo by hand, and `carrick remove` must not take that
+// away with ours. So every name init adds is also recorded under `carrick`,
+// and the remove path subtracts exactly that list and nothing else. The
+// scanner declares the same key (`WrittenByInit`) so a round trip through its
+// struct cannot drop it.
+import fs from "node:fs";
+import path from "node:path";
+/** The file, in the folder that holds the repos. */
+export const WORKSPACE_FILE = "carrick-workspace.json";
+function parse(existing) {
+    if (existing === null || existing.trim() === "")
+        return {};
+    const parsed = JSON.parse(existing);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${WORKSPACE_FILE} is not a JSON object`);
+    }
+    return parsed;
+}
+function names(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+/** The half of the document init owns, as it is written. */
+function ours(document) {
+    const section = document["carrick"];
+    if (typeof section !== "object" || section === null)
+        return [];
+    return names(section["exclude"]);
+}
+function serialize(document) {
+    return `${JSON.stringify(document, null, 2)}\n`;
+}
+/** The file as it is, or null when the folder has none. */
+export function readWorkspaceFile(workspace) {
+    try {
+        return fs.readFileSync(path.join(workspace, WORKSPACE_FILE), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The repos this folder's workspace file leaves out.
+ *
+ * Read by `carrick init` before it derives anything: the scanner has already
+ * dropped an excluded repo by the time the proposal arrives, so this is the
+ * only way the command can say which repo a `--repo` flag is asking for and
+ * where the answer was written down. An unreadable or unparseable file
+ * excludes nothing here; the scanner reports it.
+ */
+export function excludedRepos(workspace) {
+    const existing = readWorkspaceFile(workspace);
+    if (existing === null)
+        return [];
+    try {
+        return names(parse(existing)["exclude"]);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The document with these repos excluded, and the record of what we added.
+ *
+ * Idempotent: a name the file already excludes is left where it is and not
+ * claimed, whether a user put it there or an earlier run did. Everything else
+ * in the file — a `repos` list, a key this version knows nothing about, the
+ * order they are in — is kept as it was found.
+ *
+ * Throws on a file that is not JSON, exactly as the hook writers do: a file
+ * somebody hand-edited into something unparseable is reported, never
+ * overwritten.
+ */
+export function withExclusions(existing, exclude) {
+    const document = parse(existing);
+    const current = names(document["exclude"]);
+    const added = exclude.filter((name) => !current.includes(name));
+    const claimed = [...ours(document), ...added];
+    const next = { ...document, exclude: [...current, ...added] };
+    if (claimed.length > 0)
+        next["carrick"] = { exclude: claimed };
+    const body = serialize(next);
+    return { body, changed: body !== existing, added };
+}
+/**
+ * The inverse: our exclusions out, everything else kept.
+ *
+ * `carrick remove` undoes an install, and an install is the only thing this
+ * takes back. A name a user excluded by hand stays excluded, and a file that
+ * holds their repo list stays a file — it was theirs before init ran. Only a
+ * document that is nothing but what init put there is reported as one the
+ * caller may delete.
+ */
+export function withoutOurExclusions(existing) {
+    const document = parse(existing);
+    const removed = ours(document);
+    const kept = names(document["exclude"]).filter((name) => !removed.includes(name));
+    const next = {};
+    for (const [key, value] of Object.entries(document)) {
+        if (key === "carrick")
+            continue;
+        // An emptied list is dropped rather than left as `[]`: it is a key init
+        // added, and a file left holding one reads as a decision somebody made.
+        if (key === "exclude") {
+            if (kept.length > 0)
+                next["exclude"] = kept;
+            continue;
+        }
+        next[key] = value;
+    }
+    // Nothing of anyone else's left: no keys at all, or an empty `repos` list
+    // and nothing beside it.
+    const left = Object.keys(next);
+    const empty = left.length === 0 || (left.length === 1 && left[0] === "repos" && names(next["repos"]).length === 0);
+    return { body: serialize(next), changed: serialize(next) !== existing, removed, empty };
+}
+/**
+ * Write the selection into the folder, and say what was recorded.
+ *
+ * Null when there was nothing to exclude, which is the ordinary case: a single
+ * repo is not a choice, and a folder whose repos are all covered has no
+ * selection to persist and must not get a file it did not have.
+ */
+export function writeSelection(workspace, exclude) {
+    if (exclude.length === 0)
+        return null;
+    const target = path.join(workspace, WORKSPACE_FILE);
+    const written = withExclusions(readWorkspaceFile(workspace), exclude);
+    if (written.changed)
+        fs.writeFileSync(target, written.body);
+    return written;
+}
+/**
+ * Take our exclusions back out of the folder's file. Null when there was none.
+ *
+ * The file goes with them when init is the reason it exists; a file holding a
+ * user's own repo list or their own exclusions is rewritten without ours and
+ * left where it is.
+ */
+export function removeSelection(workspace) {
+    const existing = readWorkspaceFile(workspace);
+    if (existing === null)
+        return null;
+    const cleaned = withoutOurExclusions(existing);
+    if (cleaned.removed.length === 0)
+        return null;
+    const target = path.join(workspace, WORKSPACE_FILE);
+    if (cleaned.empty) {
+        fs.rmSync(target, { force: true });
+        return { file: WORKSPACE_FILE, removed: cleaned.removed, deleted: true };
+    }
+    fs.writeFileSync(target, cleaned.body);
+    return { file: WORKSPACE_FILE, removed: cleaned.removed, deleted: false };
+}
+//# sourceMappingURL=workspace-file.js.map

package/dist/init/workspace-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-file.js","sourceRoot":"","sources":["../../src/init/workspace-file.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.82",
+  "version": "0.3.83",
   "description": "The API contract index for a TypeScript workspace: what the other services do with the routes and calls in the file you are editing, in your editor and in your agent's context",
   "keywords": [
     "typescript",
@@ -57,11 +57,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.82",
-    "@carrick-tools/cli-darwin-x64": "0.3.82",
-    "@carrick-tools/cli-linux-arm64": "0.3.82",
-    "@carrick-tools/cli-linux-x64": "0.3.82",
-    "@carrick-tools/cli-win32-x64": "0.3.82"
+    "@carrick-tools/cli-darwin-arm64": "0.3.83",
+    "@carrick-tools/cli-darwin-x64": "0.3.83",
+    "@carrick-tools/cli-linux-arm64": "0.3.83",
+    "@carrick-tools/cli-linux-x64": "0.3.83",
+    "@carrick-tools/cli-win32-x64": "0.3.83"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",

package/plugin/hooks/hooks.json

@@ -22,6 +22,17 @@
           }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "carrick hook stop",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

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

@@ -22,9 +22,10 @@
  * Seam: node builtins + this bundle only.
  */
 import type { CheckVerdict } from './api.js';
-import type { ProbePlan } from './check-probe.js';
+import { type ProbePlan } from './check-probe.js';
 import { type ScrubContext } from './check-scrub.js';
 import type { PairDeepFindings } from './check-deep.js';
+import { type PairFieldReport } from './check-fields.js';
 export interface RawDiagnostic {
     /** Workspace-relative, forward-slash file path (empty for global errors). */
     file: string;
@@ -55,6 +56,14 @@ export interface ClassifyInput {
      * verdict is then not a fact either.
      */
     deepFindings?: PairDeepFindings;
+    /**
+     * The differing fields of the two types the judge compared
+     * (carrick-tools/carrick-cloud#1118), walked in the same program. Read only
+     * on a mismatch, and only to NAME what the judge already decided: it never
+     * moves a bucket and never sets `resolved`. Absent when the walk could not
+     * run, in which case the tsc text stands alone.
+     */
+    fieldReport?: PairFieldReport;
 }
 /** Classify one pair into exactly one bucket, honouring the precedence order. */
 export declare function classifyPair(input: ClassifyInput): CheckVerdict;

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

@@ -21,7 +21,9 @@
  *
  * Seam: node builtins + this bundle only.
  */
-import { scrubDiagnostic } from './check-scrub.js';
+import { decisiveAssignmentLine } from './check-probe.js';
+import { scrubDiagnostic, scrubPaths } from './check-scrub.js';
+import { describeFieldReport } from './check-fields.js';
 const PRIMARY_RE = /^(?<file>(?:[a-zA-Z]:)?[^(]*?)\((?<line>\d+),(?<col>\d+)\): error TS(?<code>\d+): (?<msg>.*)$/;
 /** Parse `tsc --pretty false` output into structured diagnostics. */
 export function parseTscOutput(stdout) {
@@ -155,31 +157,87 @@ export function classifyPair(input) {
             ...notAFact(`the ${side} sends a form-encoded body`),
         };
     }
-    // 5. Assignment-class error on the value assignment line -> incompatible.
-    const assignDiag = probeDiags.find((d) => d.line === plan.assignmentLine && ASSIGNMENT_CODES.has(d.code));
+    // 5. Assignment-class error on the DECISIVE assignment line -> incompatible.
+    //
+    // On an `http` pair that line is the JSON wire assignment, not the declared
+    // one (carrick-tools/carrick-cloud#1119). The two cannot disagree in the
+    // direction that matters: the wire comparand short-circuits to the declared
+    // type whenever that already assigns, so an error there means the shapes
+    // disagree as declared AND as serialised. A pair whose declared forms
+    // disagree only over what serialisation changes (a producer `Date` read as
+    // the `string` it becomes) has no error on this line and is not a drift.
+    const decisiveLine = decisiveAssignmentLine(plan);
+    const assignDiag = probeDiags.find((d) => d.line === decisiveLine && ASSIGNMENT_CODES.has(d.code));
     if (assignDiag) {
+        const text = scrubDiagnostic(assignDiag.message, scrubCtx, plan.sentEndpoint.alias, plan.expectedEndpoint.alias);
         return {
             ...base,
             bucket: 'incompatible',
-            diagnostic: scrubDiagnostic(assignDiag.message, scrubCtx, plan.sentEndpoint.alias, plan.expectedEndpoint.alias),
+            diagnostic: text + namedFields(input, scrubCtx),
             ...factness(input),
         };
     }
-    // Any other diagnostic on the assignment line that is not a known assignment
-    // code still means the pair could not be cleanly verified.
-    const otherAssign = probeDiags.find((d) => d.line === plan.assignmentLine);
+    // Any other diagnostic on the DECLARED assignment line that is not a known
+    // assignment code still means the pair could not be cleanly verified.
+    // A mismatch there with none on the wire line is not one of these: it is the
+    // pair the wire rule just cleared, and it falls through to `compatible`.
+    const scrub = (text) => scrubDiagnostic(text, scrubCtx, plan.sentEndpoint.alias, plan.expectedEndpoint.alias);
+    const otherAssign = probeDiags.find((d) => d.line === plan.assignmentLine && !ASSIGNMENT_CODES.has(d.code));
     if (otherAssign) {
         return {
             ...base,
             bucket: 'unverifiable',
             gate: 'assignment:other',
-            diagnostic: scrubDiagnostic(otherAssign.message, scrubCtx, plan.sentEndpoint.alias, plan.expectedEndpoint.alias),
+            diagnostic: scrub(otherAssign.message),
+            ...notAFact('the probe raised a diagnostic that is not an assignment mismatch'),
+        };
+    }
+    // The same on the WIRE line: the serialised form was never judged (a type too
+    // deep to instantiate the transform over, say). What the DECLARED forms say
+    // is then the only judgment there is, and a mismatch in them is still a
+    // mismatch — reporting it as unverifiable would hide a real one. The
+    // unjudged wire form is named, because it is the reason the usual
+    // serialisation allowance did not apply.
+    const wireOther = plan.wireAssignmentLine === undefined
+        ? undefined
+        : probeDiags.find((d) => d.line === plan.wireAssignmentLine && !ASSIGNMENT_CODES.has(d.code));
+    if (wireOther) {
+        const declaredMismatch = probeDiags.find((d) => d.line === plan.assignmentLine && ASSIGNMENT_CODES.has(d.code));
+        if (declaredMismatch) {
+            return {
+                ...base,
+                bucket: 'incompatible',
+                diagnostic: scrub(declaredMismatch.message) +
+                    ' The serialised form of the sent type could not be computed, so this' +
+                    ' compares the types as declared.' +
+                    namedFields(input, scrubCtx),
+                ...factness(input),
+            };
+        }
+        return {
+            ...base,
+            bucket: 'unverifiable',
+            gate: 'assignment:other',
+            diagnostic: scrub(wireOther.message),
             ...notAFact('the probe raised a diagnostic that is not an assignment mismatch'),
         };
     }
     // 6. No diagnostics -> compatible.
     return { ...base, bucket: 'compatible', ...factness(input) };
 }
+/**
+ * The field-level sentence appended to a mismatch diagnostic
+ * (carrick-tools/carrick-cloud#1118), or `''` when the walk found nothing to
+ * name. Scrubbed on the same terms as the tsc text: a printed member type can
+ * carry a stub-absolute `import("...")` path.
+ */
+function namedFields(input, scrubCtx) {
+    const report = input.fieldReport;
+    if (!report)
+        return '';
+    const text = describeFieldReport(report, input.plan.direction.sent, input.plan.direction.expected);
+    return text === '' ? '' : scrubPaths(text, scrubCtx);
+}
 /**
  * Whether a compared pair is a FACT about two known types (carrick#707, R1d).
  *

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

@@ -15,6 +15,7 @@
  * changes because of it, so a scan's verdicts are identical with and without
  * it — what changes is whether a reader is told the verdict is a fact.
  */
+import ts from 'typescript';
 import type { TypeProvenance } from './api.js';
 import type { ProbePlan } from './check-probe.js';
 /** Deep findings for one pair, per probe side. */
@@ -22,11 +23,22 @@ export interface PairDeepFindings {
     sent: TypeProvenance[];
     expected: TypeProvenance[];
 }
+/** The one compiler program over the assembled probes, shared by every
+ * post-judge walk (fact-ness, and the field-level report the mismatch text
+ * names). Built once: two `createProgram` calls over the same file set would
+ * double the check phase's most expensive step and could not disagree usefully
+ * anyway. `undefined` when it cannot be built at all. */
+export interface ProbeProgram {
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    probesDir: string;
+}
+export declare function openProbeProgram(probesDir: string, plans: ProbePlan[]): ProbeProgram | undefined;
 /**
  * Walk both sides of every probe in the assembled workspace.
  *
- * Returns an empty map when the program cannot be built — absence of findings
- * must never be read as "clean", so the caller treats a missing entry as
- * unresolved rather than resolved.
+ * Returns an empty map when the program could not be built — absence of
+ * findings must never be read as "clean", so the caller treats a missing entry
+ * as unresolved rather than resolved.
  */
-export declare function probeDeepFindings(probesDir: string, plans: ProbePlan[]): Map<string, PairDeepFindings>;
+export declare function probeDeepFindings(opened: ProbeProgram | undefined, plans: ProbePlan[]): Map<string, PairDeepFindings>;

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

@@ -19,37 +19,41 @@ import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { findDisqualifyingTopTypes, provenanceOf } from './deep-walk.js';
-/**
- * Walk both sides of every probe in the assembled workspace.
- *
- * Returns an empty map when the program cannot be built — absence of findings
- * must never be read as "clean", so the caller treats a missing entry as
- * unresolved rather than resolved.
- */
-export function probeDeepFindings(probesDir, plans) {
-    const results = new Map();
+export function openProbeProgram(probesDir, plans) {
     if (plans.length === 0)
-        return results;
+        return undefined;
     const configPath = path.join(probesDir, 'tsconfig.json');
     if (!fs.existsSync(configPath))
-        return results;
-    let program;
+        return undefined;
     try {
         const raw = ts.readConfigFile(configPath, (f) => fs.readFileSync(f, 'utf8'));
         if (raw.error)
-            return results;
+            return undefined;
         const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, probesDir);
         const fileNames = plans
             .map((plan) => path.join(probesDir, 'probes', plan.fileName))
             .filter((f) => fs.existsSync(f));
         if (fileNames.length === 0)
-            return results;
-        program = ts.createProgram(fileNames, { ...parsed.options, noEmit: true });
+            return undefined;
+        const program = ts.createProgram(fileNames, { ...parsed.options, noEmit: true });
+        return { program, checker: program.getTypeChecker(), probesDir };
     }
     catch {
-        return results;
+        return undefined;
     }
-    const checker = program.getTypeChecker();
+}
+/**
+ * Walk both sides of every probe in the assembled workspace.
+ *
+ * Returns an empty map when the program could not be built — absence of
+ * findings must never be read as "clean", so the caller treats a missing entry
+ * as unresolved rather than resolved.
+ */
+export function probeDeepFindings(opened, plans) {
+    const results = new Map();
+    if (!opened)
+        return results;
+    const { program, checker, probesDir } = opened;
     for (const plan of plans) {
         const file = program.getSourceFile(path.join(probesDir, 'probes', plan.fileName));
         if (!file)

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

@@ -0,0 +1,83 @@
+/**
+ * Field-level report for a pair the judge called incompatible
+ * (carrick-tools/carrick-cloud#1118).
+ *
+ * `tsc` decides. Its elaboration names ONE field and then elides the rest
+ * ("Type 'A' is not assignable to type 'B'. Property 'x' is missing"), which is
+ * not enough for a reader deciding what to change: a create endpoint that
+ * requires `username` while the client sends `userName` reads as one missing
+ * property with no hint that the sent object carries a near-neighbour.
+ *
+ * This walk enumerates the differing fields of the SAME two types the judge
+ * compared, in the SAME program, using the compiler's own assignability
+ * relation. It is not a second judge:
+ *   - it runs only after the bucket is decided and never changes one;
+ *   - it never contradicts: a difference is only named when the checker itself
+ *     says the two member types do not assign, and when it finds nothing it
+ *     adds nothing and the raw tsc text stands alone;
+ *   - it refuses the shapes where a member list is not an account of the type
+ *     (a union root, a receiver with an index signature), rather than guessing
+ *     about them.
+ *
+ * It reports one thing the judge structurally cannot: an optionality gap in the
+ * direction that still assigns (the sending side always provides a field the
+ * receiving side declares optional). That is a real drift between two sources
+ * — the receiver carries a branch that never runs — and no assignment error can
+ * exist for it. It is stated as an observation beside the verdict, never as the
+ * verdict.
+ *
+ * Seam: node builtins + `typescript` + this bundle only.
+ */
+import type { ProbePlan, Side } from './check-probe.js';
+import type { ProbeProgram } from './check-deep.js';
+/** What kind of difference one field path carries. */
+export type FieldDifferenceNature = 
+/** The receiving side declares it; the sending side has no such member. */
+'missing_in_sent'
+/** The sending side provides it; the receiving side declares no such member. */
+ | 'extra_in_sent'
+/** Optional where it is sent, required where it is read. */
+ | 'optional_in_sent'
+/** Always sent, optional where it is read (no assignment error can exist). */
+ | 'optional_in_expected'
+/** Both declare it and the member types do not assign. */
+ | 'type_differs';
+export interface FieldDifference {
+    /** Dotted member path from the compared root (`''` is the root itself). */
+    path: string;
+    nature: FieldDifferenceNature;
+    /** Printed member type on the sending side, for `type_differs`. */
+    sentText?: string;
+    /** Printed member type on the receiving side, for `type_differs`. */
+    expectedText?: string;
+}
+export interface PairFieldReport {
+    /** Named differences, capped and ordered deterministically. */
+    differences: FieldDifference[];
+    /** How many further differences were found beyond the cap. */
+    truncated: number;
+    /**
+     * Whether the sent type's JSON wire form differs from its declared form, so
+     * the comparison the reader is being shown is against the serialised shape
+     * (a `Date` compared as the string it serialises to).
+     */
+    wireApplied: boolean;
+}
+/**
+ * Cap on named fields. A mismatch with more differing members than this is
+ * better described as two unrelated shapes than as a list, and the text says
+ * how many more there are rather than pretending the list is complete.
+ */
+export declare const MAX_NAMED_FIELDS = 8;
+/**
+ * Field reports for every plan whose probe the program could read, keyed by
+ * pair id. A plan with no entry has no report, which is not a claim that its
+ * types agree.
+ */
+export declare function pairFieldReports(opened: ProbeProgram | undefined, plans: ProbePlan[]): Map<string, PairFieldReport>;
+/**
+ * The sentence appended to a mismatch diagnostic. Names the two sides as
+ * producer and consumer (never the probe's internal sent/expected), so the
+ * reader knows which repo to change.
+ */
+export declare function describeFieldReport(report: PairFieldReport, sentSide: Side, expectedSide: Side): string;