@adecore/agents 0.39.0 → 0.40.1

package/src/chat/chat-store.ts

@@ -81,13 +81,17 @@ function liftUiAccess(record: unknown): unknown {
     if (typeof record !== 'object' || record === null || 'uiAccess' in record || !Array.isArray((record as { items?: unknown }).items)) {
         return record;
     }
+
     const uiAccess: Record<string, unknown> = {};
+
     for (const item of (record as { items: unknown[] }).items) {
         const queries = (item as { uiQueries?: unknown } | null)?.uiQueries;
+
         if (typeof queries === 'object' && queries !== null && 'access' in queries) {
             uiAccess[String((item as { id: unknown }).id)] = queries.access;
         }
     }
+
     return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
 
@@ -119,26 +123,31 @@ export class ChatStore {
     /* Every chat with a record or a log, for the scan at start. */
     async list(): Promise<string[]> {
         let names: string[];
+
         try {
             names = await readdir(this.dir);
         } catch (e) {
             if (isNotFound(e)) {
                 return [];
             }
+
             throw e;
         }
+
         const ids = names
             // A chat's bookmarks and visuals, and whatever a host keeps per chat, sit beside its record under names that also end in .json.
             .filter(
                 (name) => (name.endsWith('.json') && !isBookmarkFileName(name) && !isVisualFileName(name) && !this.isSidecar(name)) || name.endsWith('.log')
             )
             .map((name) => decodeURIComponent(name.replace(/\.(json|log)$/, '')));
+
         return [...new Set(ids)];
     }
 
     /* Whether anything of the chat is on disk, without reading it: a record or a log. */
     async has(chatId: string): Promise<boolean> {
         const found = await Promise.all([exists(join(this.dir, recordFileName(chatId))), exists(this.logPath(chatId))]);
+
         return found.includes(true);
     }
 
@@ -146,6 +155,7 @@ export class ChatStore {
     async discardLog(chatId: string): Promise<number> {
         const lines = parseLog((await readOrNull(this.logPath(chatId))) ?? '');
         await rm(this.logPath(chatId), { force: true });
+
         return lines.at(-1)?.seq ?? 0;
     }
 
@@ -162,6 +172,7 @@ export class ChatStore {
         const body = recordBody(info, items, at, preambles, extras, uiAccess);
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
         await writeAtomic(join(this.dir, recordFileName(chatId)), body);
+
         return body.length;
     }
 
@@ -186,25 +197,32 @@ export class ChatStore {
     async read(chatId: string): Promise<ChatRecord | null> {
         const lines = parseLog((await readOrNull(this.logPath(chatId))) ?? '');
         const snapshot = await this.readSnapshot(chatId);
+
         if (snapshot === UNREADABLE) {
             return null;
         }
+
         if (snapshot === null) {
             return fromLogAlone(lines);
         }
+
         const seq = snapshot.seq ?? 0;
         const thread = new ChatThread(snapshot.info, snapshot.items);
         let resetSeq = snapshot.resetSeq ?? 0;
+
         for (const line of lines) {
             // A crash between writing a snapshot and folding the log into it leaves lines the snapshot already holds.
             if (line.seq <= seq) {
                 continue;
             }
+
             thread.apply(line.event);
+
             if (line.event.type === 'reset') {
                 resetSeq = line.seq;
             }
         }
+
         return {
             ...thread.snapshot(),
             seq,
@@ -233,30 +251,39 @@ export class ChatStore {
         if (!settledInfo(await leadingInfo(join(this.dir, recordFileName(chatId))))) {
             return false;
         }
+
         const last = lastLoggedInfo((await readOrNull(this.logPath(chatId))) ?? '');
+
         return last === undefined || settledInfo(last);
     }
 
     private async readSnapshot(chatId: string): Promise<z.infer<typeof RecordSchema> | typeof UNREADABLE | null> {
         const raw = await readOrNull(join(this.dir, recordFileName(chatId)));
+
         if (raw === null) {
             return null;
         }
+
         let record: unknown;
+
         try {
             record = JSON.parse(raw);
         } catch {
             return UNREADABLE;
         }
+
         // Before the schema sees it: an image written inline no longer has a shape the schema knows.
         if (this.attachments) {
             const migrated = await migrateInlineAttachments(chatId, record, this.attachments).catch(() => null);
+
             if (migrated !== null) {
                 record = migrated;
                 await writeAtomic(join(this.dir, recordFileName(chatId)), JSON.stringify(migrated));
             }
         }
+
         const parsed = RecordSchema.safeParse(liftUiAccess(record));
+
         return parsed.success ? parsed.data : UNREADABLE;
     }
 
@@ -281,14 +308,17 @@ const CLOSE_BRACE = 0x7d;
  */
 async function leadingInfo(path: string): Promise<unknown> {
     let handle: Awaited<ReturnType<typeof open>>;
+
     try {
         handle = await open(path, 'r');
     } catch (e) {
         if (isNotFound(e)) {
             return undefined;
         }
+
         throw e;
     }
+
     try {
         let head = Buffer.alloc(0);
         let at = RECORD_HEAD.length;
@@ -297,13 +327,17 @@ async function leadingInfo(path: string): Promise<unknown> {
         let escaped = false;
         const chunk = Buffer.alloc(HEAD_CHUNK_BYTES);
         let { bytesRead } = await handle.read(chunk, 0, chunk.length, 0);
+
         while (bytesRead > 0) {
             head = Buffer.concat([head, chunk.subarray(0, bytesRead)]);
+
             if (!head.subarray(0, RECORD_HEAD.length).equals(RECORD_HEAD.subarray(0, Math.min(head.length, RECORD_HEAD.length)))) {
                 return undefined;
             }
+
             for (; at < head.length; at++) {
                 const byte = head[at]!;
+
                 if (escaped) {
                     escaped = false;
                 } else if (inString) {
@@ -315,13 +349,16 @@ async function leadingInfo(path: string): Promise<unknown> {
                     depth += 1;
                 } else if (byte === CLOSE_BRACE) {
                     depth -= 1;
+
                     if (depth === 0) {
                         return parseOrUndefined(head.subarray(RECORD_HEAD.length - 1, at + 1).toString('utf8'));
                     }
                 }
             }
+
             ({ bytesRead } = await handle.read(chunk, 0, chunk.length, head.length));
         }
+
         return undefined;
     } finally {
         await handle.close();
@@ -331,16 +368,20 @@ async function leadingInfo(path: string): Promise<unknown> {
 /* The info of the last info or reset line in a log, unvalidated; undefined when no line carries one. */
 function lastLoggedInfo(raw: string): unknown {
     const lines = raw.split('\n');
+
     for (let i = lines.length - 1; i >= 0; i--) {
         // Most lines are items and deltas, which are larger and never carry this key.
         if (!lines[i]!.includes('"info"')) {
             continue;
         }
+
         const event = (parseOrUndefined(lines[i]!) as { event?: { type?: unknown; info?: unknown } } | null | undefined)?.event;
+
         if (event?.type === 'info' || event?.type === 'reset') {
             return event.info;
         }
     }
+
     return undefined;
 }
 
@@ -359,11 +400,13 @@ function parseOrUndefined(text: string): unknown {
 async function exists(path: string): Promise<boolean> {
     try {
         await stat(path);
+
         return true;
     } catch (e) {
         if (isNotFound(e)) {
             return false;
         }
+
         throw e;
     }
 }
@@ -375,6 +418,7 @@ async function readOrNull(path: string): Promise<string | null> {
         if (isNotFound(e)) {
             return null;
         }
+
         throw e;
     }
 }
@@ -389,17 +433,23 @@ function fromLogAlone(lines: ChatLogLine[]): ChatRecord | null {
     if (lines.length === 0) {
         return null;
     }
+
     const first = lines.find((line) => line.event.type === 'info' || line.event.type === 'reset')?.event;
+
     if (lines[0]!.seq !== 1 || (first?.type !== 'info' && first?.type !== 'reset')) {
         return null;
     }
+
     const thread = new ChatThread(first.info);
     let resetSeq = 0;
+
     for (const line of lines) {
         thread.apply(line.event);
+
         if (line.event.type === 'reset') {
             resetSeq = line.seq;
         }
     }
+
     return { ...thread.snapshot(), seq: 0, resetSeq, preambles: [], uiAccess: {}, extras: {}, lines };
 }

package/src/chat/chat-title.ts

@@ -45,19 +45,25 @@ export function buildTitlePrompt(prompt: string, answer: string): string {
 export function parseTitle(output: string): string | null {
     const start = [...output.matchAll(/\{\s*"title"/g)].at(-1)?.index;
     const end = output.lastIndexOf('}');
+
     if (start === undefined || end < start) {
         return null;
     }
+
     let parsed: unknown;
+
     try {
         parsed = JSON.parse(output.slice(start, end + 1));
     } catch {
         return null;
     }
+
     if (typeof parsed !== 'object' || parsed === null || !('title' in parsed)) {
         return null;
     }
+
     const title = cleanTitle(parsed.title);
+
     return title === null ? null : cleanTitle(title.replace(/^["'`]+|["'`.]+$/g, ''));
 }
 
@@ -74,11 +80,14 @@ export async function suggestChatTitle(
 ): Promise<string | null> {
     const provider = await registry.oneShotProvider(preferred);
     const args = provider?.oneShotArgs?.(buildTitlePrompt(input.prompt, input.answer)) ?? null;
+
     if (provider === null || args === null) {
         return null;
     }
+
     try {
         const result = await runProcess([provider.command[0]!, ...args], { cwd: input.cwd, timeoutMs: TIMEOUT_MS, ...(env === undefined ? {} : { env }) });
+
         return result.exitCode === 0 ? parseTitle(result.stdout) : null;
     } catch {
         return null;

package/src/chat/claude-backend.ts

@@ -56,7 +56,9 @@ export class ClaudeBackend implements ChatBackend {
         if (this.child) {
             return Promise.resolve();
         }
+
         const { selection, runtimeMode, resume, folders, projectConfig } = this.launch;
+
         const args = [
             ...this.launch.command,
             ...claudeArgs({
@@ -68,10 +70,13 @@ export class ClaudeBackend implements ChatBackend {
                 ...(projectConfig === undefined ? {} : { projectConfig })
             })
         ];
+
         if (this.launch.instructions !== null) {
             args.push('--append-system-prompt', this.launch.instructions);
         }
+
         this.stdinClosed = false;
+
         const child: ChatChild = new ChatChild({
             command: args,
             cwd: this.launch.cwd,
@@ -80,8 +85,10 @@ export class ClaudeBackend implements ChatBackend {
             onError: (error) => this.broken(error),
             onExit: (exitCode, stderr) => this.handleExit(child, exitCode, stderr)
         });
+
         this.child = child;
         void this.readLines(child);
+
         return Promise.resolve();
     }
 
@@ -96,10 +103,13 @@ export class ClaudeBackend implements ChatBackend {
         if (!this.child || !this.active || this.stdinClosed) {
             return Promise.resolve(false);
         }
+
         const promptId = input.promptId ?? randomUUID();
+
         return new Promise((resolve, reject) => {
             this.steers.set(promptId, { resolve, reject });
             this.protocol.beginSteer(promptId);
+
             try {
                 this.write(this.userMessage(input, promptId));
             } catch (error) {
@@ -118,6 +128,7 @@ export class ClaudeBackend implements ChatBackend {
         this.interrupted = true;
         this.protocol.noteInterrupt();
         this.write({ type: 'control_request', request_id: `interrupt-${Date.now()}`, request: { subtype: 'interrupt' } });
+
         // A steer the CLI has not taken in survives a plain interrupt and would run after the Stop; it goes back to the queue instead.
         for (const promptId of this.steers.keys()) {
             this.write({
@@ -134,25 +145,31 @@ export class ClaudeBackend implements ChatBackend {
 
     respondApproval(requestId: string, decision: ApprovalDecision, message?: string): boolean {
         const frame = this.protocol.approvalResponse(requestId, decision, message);
+
         if (frame === null) {
             return false;
         }
+
         return this.respond(requestId, frame);
     }
 
     respondQuestion(requestId: string, answers: Record<string, string>): boolean {
         const frame = this.protocol.questionResponse(requestId, answers);
+
         if (frame === null) {
             return false;
         }
+
         return this.respond(requestId, frame);
     }
 
     declineRequest(requestId: string, message: string): boolean {
         const frame = this.protocol.declineResponse(requestId, message);
+
         if (frame === null) {
             return false;
         }
+
         return this.respond(requestId, frame);
     }
 
@@ -165,12 +182,14 @@ export class ClaudeBackend implements ChatBackend {
         this.rejectSteers('Claude stopped before acknowledging your message');
         const child = this.child;
         this.child = null;
+
         return child?.end() ?? Promise.resolve();
     }
 
     private userMessage(input: TurnInput, promptId: string): Record<string, unknown> {
         // What the CLI must see first (ultrathink), then the preamble, then what was typed.
         const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+
         return buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId });
     }
 
@@ -196,33 +215,43 @@ export class ClaudeBackend implements ChatBackend {
         if (this.child !== child || line.trim() === '') {
             return;
         }
+
         let frame: unknown;
+
         try {
             frame = JSON.parse(line);
         } catch {
             return;
         }
+
         const echoed = typeof frame === 'object' && frame !== null ? (frame as Record<string, unknown>) : null;
+
         if (echoed?.type === 'control_response' && this.cancelledSteer(echoed.response)) {
             return;
         }
+
         if (echoed?.type === 'user' && typeof echoed.uuid === 'string' && echoed.parent_tool_use_id == null) {
             this.steers.get(echoed.uuid)?.resolve(true);
             this.steers.delete(echoed.uuid);
+
             if (this.steers.size === 0) {
                 this.clearSteerTimer();
             }
         }
+
         for (const event of this.protocol.handle(frame)) {
             if (event.type === 'turn.done') {
                 this.active = false;
                 this.awaitSteers();
             }
+
             if (event.type === 'turn.done' && this.interrupted) {
                 this.interrupted = false;
                 this.host.onEvent({ ...event, state: 'aborted' });
+
                 continue;
             }
+
             this.host.onEvent(event);
         }
     }
@@ -240,18 +269,24 @@ export class ClaudeBackend implements ChatBackend {
         if (typeof response !== 'object' || response === null) {
             return false;
         }
+
         const { request_id: requestId, response: body } = response as { request_id?: unknown; response?: unknown };
+
         if (typeof requestId !== 'string' || !requestId.startsWith(CANCEL_STEER)) {
             return false;
         }
+
         const promptId = requestId.slice(CANCEL_STEER.length);
+
         if (typeof body === 'object' && body !== null && (body as { cancelled?: unknown }).cancelled === true) {
             this.steers.get(promptId)?.resolve(false);
             this.steers.delete(promptId);
+
             if (this.steers.size === 0) {
                 this.clearSteerTimer();
             }
         }
+
         return true;
     }
 
@@ -259,13 +294,17 @@ export class ClaudeBackend implements ChatBackend {
         if (this.steers.size === 0 || this.steerTimer !== null) {
             return;
         }
+
         this.steerTimer = setTimeout(() => {
             this.steerTimer = null;
+
             for (const pending of this.steers.values()) {
                 pending.reject(new Error('Claude ended its turn without taking your message'));
             }
+
             this.steers.clear();
         }, STEER_GRACE_MS);
+
         this.steerTimer.unref?.();
     }
 
@@ -279,9 +318,11 @@ export class ClaudeBackend implements ChatBackend {
     private rejectSteers(reason: string): void {
         this.active = false;
         this.clearSteerTimer();
+
         for (const pending of this.steers.values()) {
             pending.reject(new Error(reason));
         }
+
         this.steers.clear();
     }
 
@@ -294,6 +335,7 @@ export class ClaudeBackend implements ChatBackend {
     private failed(error: unknown): void {
         this.rejectSteers(`Lost the connection to Claude: ${errorText(error)}`);
         this.protocol.forgetPending();
+
         try {
             this.host.onEvent({ type: 'failed', message: `Lost the connection to Claude: ${errorText(error)}`, processAlive: this.running });
         } catch (reportError) {
@@ -304,24 +346,29 @@ export class ClaudeBackend implements ChatBackend {
     private respond(requestId: string, frame: unknown): boolean {
         try {
             this.write(frame);
+
             return true;
         } catch (error) {
             this.host.onEvent({ type: 'request.withdrawn', requestId });
             this.failed(error);
+
             return false;
         }
     }
 
     private write(frame: unknown): void {
         const child = this.child;
+
         if (!child || this.stdinClosed) {
             throw new Error('Claude stdin is closed');
         }
+
         try {
             child.process.stdin.write(`${JSON.stringify(frame)}\n`);
             child.process.stdin.flush();
         } catch (error) {
             this.stdinClosed = true;
+
             throw error;
         }
     }
@@ -330,7 +377,9 @@ export class ClaudeBackend implements ChatBackend {
         if (!this.child || this.stdinClosed) {
             return;
         }
+
         this.stdinClosed = true;
+
         try {
             this.child.process.stdin.end();
         } catch {
@@ -342,6 +391,7 @@ export class ClaudeBackend implements ChatBackend {
         if (this.child !== child) {
             return;
         }
+
         this.child = null;
         this.rejectSteers('Claude stopped before it got your message');
         this.protocol.forgetPending();