@cueloop/daemon 0.1.0-alpha.102 → 0.1.0-alpha.103

package/src/thread-review.test.ts

@@ -308,7 +308,9 @@ describe("awaitMessage: one long-poll (the hook shape)", () => {
 
     // Assert
     expect(message).not.toBe("pending");
+
     if (message === "pending") throw new Error("unreachable");
+
     expect(message.allow).toBe(true);
     expect(message.message.body).toContain("Fine.");
     expect(message.session.message!.outcome).toBe("approved");
@@ -325,6 +327,7 @@ describe("awaitMessage: one long-poll (the hook shape)", () => {
 
     // Assert
     if (message === "pending") throw new Error("expected a message");
+
     expect(message.allow).toBe(false);
     expect(message.message.body).toContain("# Review: changes requested");
     expect(message.message.body).toContain("One stage only.");
@@ -362,6 +365,7 @@ describe("awaitMessage: chunked loop (the pi shape)", () => {
 
     // Assert
     if (message === "pending") throw new Error("expected a message");
+
     expect(message.allow).toBe(false);
     expect(message.session.annotations.length).toBe(1);
   }, 15_000);

package/src/thread-review.ts

@@ -43,6 +43,7 @@ async function jjRoot(cwd: string): Promise<string | null> {
 /** The oldest root commit reachable from HEAD; the project key that survives moving or re-cloning the repo. */
 function earliestRootCommit(revList: string | null): string | undefined {
   if (!revList) return undefined;
+
   const roots = revList.split("\n").filter((line) => line.length > 0);
 
   // --date-order lists newest first, so the last root is the earliest
@@ -77,6 +78,7 @@ export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKe
 
   // a repo with no commits (or a shallow clone) has no reliable root, so the thread stays standalone
   if (rootCommit) workspace.rootCommit = rootCommit;
+
   if (remote) workspace.remote = remote;
 
   return workspace;
@@ -191,6 +193,7 @@ export class ReviewHandle {
 
       return resolved === null ? "pending" : outcome(resolved);
     }
+
     const chunkMs = pollMs ?? 10_000;
     const deadline = Number.isFinite(timeoutMs) ? Date.now() + timeoutMs : undefined;
 
@@ -198,11 +201,13 @@ export class ReviewHandle {
       const budget = deadline === undefined ? chunkMs : Math.min(chunkMs, deadline - Date.now());
 
       if (budget <= 0 || signal?.aborted) return "pending";
+
       const resolved = await raceAbort(this.client.sessionWait(this.session.id, budget), signal);
 
       if (resolved === ABORTED) return "pending";
 
       if (resolved !== null) return outcome(resolved);
+
       // Still pending after this chunk: re-read to surface reviewer progress.
       const current = await raceAbort(this.client.sessionGet(this.session.id), signal);
 
@@ -278,6 +283,7 @@ export async function findExistingReview(
     return candidates.find(
       (candidate) => candidate.artifact.meta.vcsChangeId === options.vcsChangeId,
     );
+
   if (isJjDiff) {
     const jjCandidates = candidates.filter(hasJjProvenance);
 
@@ -295,6 +301,7 @@ async function matchingDiffCapture(
   cwd: string,
 ): Promise<{ source?: DiffSource; files?: DiffFileContents[] }> {
   if (options.type !== "diff" || options.pr || !options.content.trim()) return {};
+
   try {
     const captured = await new VcsSourceManager().capture(cwd, options.vcs);
 
@@ -347,6 +354,7 @@ export async function openReview(
 
     return new ReviewHandle(client, revised);
   }
+
   let session = await client.sessionCreate(workspace, {
     type: options.type,
     content: options.content,

package/src/thread-subscription.test.ts

@@ -91,6 +91,7 @@ test("reconnect subscribes again and refreshes authoritative state even without
       },
       onValue: (state) => {
         values.push(state.artifact.meta.title ?? "Initial");
+
         if (connections === 1) initial.resolve();
         else recovered.resolve();
       },
@@ -126,6 +127,7 @@ test("a malformed protocol frame stops the observer instead of reconnecting", as
       open(socket) {
         reads.set(socket, new LineBuffer());
         connections++;
+
         if (connections > 1) failed.reject(new Error("Unexpected reconnect"));
       },
       data(socket, bytes) {
@@ -141,6 +143,7 @@ test("a malformed protocol frame stops the observer instead of reconnecting", as
                   : {},
             }) + "\n",
           );
+
           if (request.method === "events.subscribe") socket.write("{broken\n");
         });
       },

package/src/thread-subscription.ts

@@ -34,11 +34,13 @@ export function subscribeThreadState<Value>(options: ThreadSubscriptionOptions<V
 
     try {
       api = await options.connect();
+
       if (stopped || epoch !== generation) {
         api.close();
 
         return;
       }
+
       connection = api;
       const current = api;
       const refresh = async () => {
@@ -62,6 +64,7 @@ export function subscribeThreadState<Value>(options: ThreadSubscriptionOptions<V
               detach?.();
               current.close();
             }
+
             options.onError(error);
           }
         } finally {
@@ -73,11 +76,13 @@ export function subscribeThreadState<Value>(options: ThreadSubscriptionOptions<V
       });
       const offDisconnect = api.onDisconnect((reason) => {
         if (stopped || epoch !== generation) return;
+
         ++generation;
         detach?.();
         for (const read of reads) read.abort();
         connection = undefined;
         current.close();
+
         if (isFatalSubscriptionError(reason)) {
           stopped = true;
           options.onError(reason);
@@ -89,16 +94,20 @@ export function subscribeThreadState<Value>(options: ThreadSubscriptionOptions<V
         offDisconnect();
       };
       await api.subscribe();
+
       if (stopped || epoch !== generation) return;
+
       options.onConnect?.(api);
       await refresh();
     } catch (error) {
       if (stopped || epoch !== generation) return;
+
       ++generation;
       detach?.();
       api?.close();
       connection = undefined;
       options.onError(error);
+
       if (!(error instanceof Error && isFatalSubscriptionError(error))) schedule();
     }
   };

package/src/validate.test.ts

@@ -58,6 +58,7 @@ describe("parseParams", () => {
       throw new Error("should have thrown");
     } catch (err) {
       expect(err).toBeInstanceOf(DaemonError);
+
       if (err instanceof DaemonError) {
         expect(err.code).toBe("invalid_params");
         expect(err.message).toContain("session.create: workspace");
@@ -180,6 +181,7 @@ describe("validateThreadRecord", () => {
 
     // Assert
     expect(result.ok).toBe(false);
+
     if (!result.ok) expect(result.error).toContain("schemaVersion");
   });
 
@@ -366,6 +368,7 @@ describe("wire pins", () => {
 
     // Assert
     expect(parsed.ok).toBe(false);
+
     if (!parsed.ok) expect(parsed.error).toContain("history:");
   });
 
@@ -376,6 +379,7 @@ describe("wire pins", () => {
     });
 
     expect(result.ok).toBe(false);
+
     if (!result.ok) {
       expect(result.error).toContain(
         "text Cuts do not match the submitted artifact and working copy",

package/src/validate.ts

@@ -478,6 +478,7 @@ export const SessionHistorySchema = v.pipe(
   // the shape is not enough: the tree itself must hold, or a walk hangs or rewires the path
   v.rawCheck(({ dataset, addIssue }) => {
     if (!dataset.typed) return;
+
     const problem = validateHistory(dataset.value);
 
     if (problem !== null) addIssue({ message: `history: ${problem}` });
@@ -519,6 +520,7 @@ export const ThreadRecordSchema = v.pipe(
   } satisfies EntriesOf<Thread>),
   v.rawCheck(({ dataset, addIssue }) => {
     if (!dataset.typed || !dataset.value.textCuts?.length) return;
+
     const { artifact, textCuts, workingCopy } = dataset.value;
     const matchesSource = textCuts.every(
       (cut) => artifact.content.slice(cut.start, cut.end) === cut.quote,
@@ -536,6 +538,7 @@ export function validateThreadRecord(
   const result = v.safeParse(ThreadRecordSchema, raw);
 
   if (result.success) return { ok: true, value: result.output };
+
   const issue = result.issues[0]!;
   const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
 

package/src/vcs-source.ts

@@ -71,6 +71,7 @@ const ExtensionModuleSchema = v.object({ default: v.function() });
 
 function readVcsToml(path: string): Partial<VcsConfig> {
   if (!existsSync(path)) return {};
+
   try {
     const parsed = v.safeParse(VcsConfigSchema, parseToml(readFileSync(path, "utf8")));
 
@@ -100,6 +101,7 @@ export class VcsSourceManager {
 
   private async adapters(): Promise<VcsAdapter[]> {
     if (!this.loaded) this.loaded = this.loadExtensions();
+
     await this.loaded;
 
     return [
@@ -131,6 +133,7 @@ export class VcsSourceManager {
       const parsed = v.safeParse(ExtensionModuleSchema, module);
 
       if (!parsed.success) throw new Error("VCS extension must export a default factory");
+
       const factory: ExtensionFactory = async (api) => {
         await parsed.output.default(api);
       };
@@ -177,6 +180,7 @@ export class VcsSourceManager {
 
       if (!selected && requested === "git" && detected.length === 0)
         return { adapter: gitVcsAdapter, repoRoot: cwd };
+
       if (!selected)
         throw new Error(
           `VCS adapter unavailable: ${requested}${this.extensionErrors.length > 0 ? ` (${this.extensionErrors.join("; ")})` : ""}`,
@@ -184,6 +188,7 @@ export class VcsSourceManager {
 
       return selected;
     }
+
     detected.sort((a, b) => {
       const rootDistance = b.repoRoot.length - a.repoRoot.length;
 
@@ -219,6 +224,7 @@ export class VcsSourceManager {
 
     if (!selected.adapter.captureChange)
       throw new Error(`VCS adapter ${provider} cannot follow a change ID`);
+
     const snapshot = v.parse(
       VcsDiffSnapshotSchema,
       await selected.adapter.captureChange(selected.repoRoot, changeId),

package/src/working-tree.ts

@@ -17,6 +17,7 @@ function statusFromCode(code: string): DiffFileStatus {
   const letter = code.charAt(0);
 
   if (letter === "D") return "deleted";
+
   if (letter === "A") return "added";
 
   return "modified";
@@ -35,6 +36,7 @@ export async function workingChangeList(
 
   for (const line of tracked.split("\n")) {
     if (line.trim().length === 0) continue;
+
     const parts = line.split("\t");
 
     // a rename is "R100<tab>old<tab>new"; the new path (last field) is what the reviewer opens
@@ -101,11 +103,13 @@ async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
       cursor += 2;
       continue;
     }
+
     const path = tokens[cursor++]!;
     const oldContents = code === "A" ? "" : await headContents(path, cwd);
     const newContents = code === "D" ? "" : await workingContents(path, cwd);
 
     if (looksBinary(oldContents) || looksBinary(newContents)) continue;
+
     const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
 
     files.push({ path, oldContents, newContents, status });