@adecore/agents 0.38.0 → 0.40.0

package/src/chat/claude-title.ts

@@ -33,26 +33,32 @@ export class ClaudeTitleReader {
     /* The title of a session found by its id, for a chat, which knows no transcript path; in the projects of its account, its own folder first. */
     async forSession(agentSessionId: string, projectsDir: string = this.projectsDir, cwd?: string): Promise<string | null> {
         const path = await findClaudeSession(projectsDir, agentSessionId, cwd);
+
         return path === null ? null : await this.forTranscript(path);
     }
 
     async forTranscript(path: string): Promise<string | null> {
         let size: number;
+
         try {
             size = (await stat(path)).size;
         } catch {
             return null;
         }
+
         let progress = this.progress.get(path);
+
         // Smaller than where we were is a file that was replaced, not one that grew.
         if (!progress || size < progress.offset) {
             progress = { offset: 0, aiTitle: null, customTitle: null };
             this.progress.set(path, progress);
         }
+
         if (size > progress.offset) {
             const current = progress;
             current.offset = await readLines(path, current.offset, size, this.chunkBytes, (line) => this.take(line, current));
         }
+
         return progress.customTitle ?? progress.aiTitle;
     }
 
@@ -60,15 +66,19 @@ export class ClaudeTitleReader {
         if (!MARKERS.some((marker) => line.includes(marker))) {
             return;
         }
+
         let record: unknown;
+
         try {
             record = JSON.parse(line);
         } catch {
             return;
         }
+
         if (!isRecord(record)) {
             return;
         }
+
         if (record.type === 'ai-title') {
             progress.aiTitle = cleanTitle(record.aiTitle) ?? progress.aiTitle;
         } else if (record.type === 'custom-title') {

package/src/chat/claude-transcript.ts

@@ -3,6 +3,7 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import type { ChatHistoryResult, ChatItem } from '@adecore/agent-contracts';
 import { isRecord } from '@adecore/agent-contracts';
+import { filledStr as str } from '../fields.ts';
 import { fileExists } from '../fs.ts';
 import { readLines } from '../title-file.ts';
 import { ClaudeProtocol } from './claude-protocol.ts';
@@ -12,19 +13,18 @@ import type { ChatThread } from './thread.ts';
 
 const CHUNK_BYTES = 4 * 1024 * 1024;
 
-function str(value: unknown): string | null {
-    return typeof value === 'string' && value !== '' ? value : null;
-}
-
 /* The words of a user line that somebody said, or null for a line that carries tool results. */
 export function spokenText(content: unknown): string | null {
     if (typeof content === 'string') {
         return content;
     }
+
     if (!Array.isArray(content) || content.some((block) => isRecord(block) && block.type === 'tool_result')) {
         return null;
     }
+
     const texts = content.filter((block) => isRecord(block) && block.type === 'text').map((block) => String((block as { text?: unknown }).text ?? ''));
+
     return texts.length === 0 ? null : texts.join('\n');
 }
 
@@ -56,67 +56,89 @@ export async function findClaudeSession(projectsDir: string, sessionId: string,
     if (projectsDir === '' || sessionId === '' || /[/\\]|\.\./.test(sessionId)) {
         return null;
     }
+
     const file = `${sessionId}.jsonl`;
     const key = `${projectsDir}\n${sessionId}`;
     const own = cwd === undefined ? null : join(projectsDir, claudeProjectSlug(cwd), file);
+
     if (own !== null && (await fileExists(own))) {
         sessionPaths.set(key, own);
+
         return own;
     }
+
     const known = sessionPaths.get(key);
+
     if (known !== undefined && known !== own && (await fileExists(known))) {
         return known;
     }
+
     sessionPaths.delete(key);
     let dirs: string[];
+
     try {
         dirs = await readdir(projectsDir);
     } catch {
         return null;
     }
+
     const candidates = dirs.map((dir) => join(projectsDir, dir, file)).filter((candidate) => candidate !== own);
     const present = await Promise.all(candidates.map(fileExists));
     const found = candidates.find((_candidate, i) => present[i]) ?? null;
+
     if (found !== null) {
         sessionPaths.set(key, found);
     }
+
     return found;
 }
 
 /* Where the subagents of a session keep their transcripts: the folder beside its own transcript, once the CLI made it. */
 export async function findSubagentsDir(projectsDir: string, cwd: string, sessionId: string): Promise<string | null> {
     const transcript = await findClaudeSession(projectsDir, sessionId, cwd);
+
     if (transcript === null) {
         return null;
     }
+
     const dir = join(dirname(transcript), sessionId, 'subagents');
+
     return (await fileExists(dir)) ? dir : null;
 }
 
 /* Every meta file in a subagents folder that says which agent it is about; one that does not parse is left out. */
 export async function readSubagentMetas(dir: string): Promise<SubagentMeta[]> {
     let names: string[];
+
     try {
         names = await readdir(dir);
     } catch {
         return [];
     }
+
     const metas: SubagentMeta[] = [];
+
     for (const name of names) {
         const match = /^agent-(.+)\.meta\.json$/.exec(name);
+
         if (!match) {
             continue;
         }
+
         let parsed: unknown;
+
         try {
             parsed = JSON.parse(await readFile(join(dir, name), 'utf8'));
         } catch {
             continue;
         }
+
         if (!isRecord(parsed)) {
             continue;
         }
+
         const agentId = match[1]!;
+
         metas.push({
             agentId,
             toolUseId: str(parsed.toolUseId),
@@ -125,6 +147,7 @@ export async function readSubagentMetas(dir: string): Promise<SubagentMeta[]> {
             transcript: join(dir, `agent-${agentId}.jsonl`)
         });
     }
+
     return metas;
 }
 
@@ -136,20 +159,25 @@ export async function findWorkflowAgent(subagentsDir: string, agentId: string):
     if (!/^[\w-]+$/.test(agentId)) {
         return null;
     }
+
     const workflowsDir = join(subagentsDir, 'workflows');
     let runs: string[];
+
     try {
         runs = await readdir(workflowsDir);
     } catch {
         return null;
     }
+
     for (const run of runs) {
         const dir = join(workflowsDir, run);
         const transcript = join(dir, `agent-${agentId}.jsonl`);
+
         if (existsSync(transcript)) {
             return { agentId, toolUseId: null, parentAgentId: null, description: null, transcript };
         }
     }
+
     return null;
 }
 
@@ -178,19 +206,24 @@ export class TranscriptProjection {
     /* Reads what was added since the last call; false when the file is not there. */
     async refresh(): Promise<boolean> {
         let info: { size: number; mtimeMs: number };
+
         try {
             info = await stat(this.path);
         } catch {
             return false;
         }
+
         if (info.size < this.size || info.mtimeMs < this.mtimeMs) {
             this.reset();
         }
+
         this.size = info.size;
         this.mtimeMs = info.mtimeMs;
+
         if (info.size > this.offset) {
             this.offset = await readLines(this.path, this.offset, info.size, CHUNK_BYTES, (line) => this.take(line));
         }
+
         return true;
     }
 
@@ -201,6 +234,7 @@ export class TranscriptProjection {
     /* The page before `cursor`, or the newest page without one; the cursors are the thread's own. */
     page(limit: number, cursor?: string): ChatHistoryResult {
         const page = this.thread.history(limit, cursor);
+
         return { items: page.items.map(settledReading), history: page.history };
     }
 
@@ -218,21 +252,28 @@ export class TranscriptProjection {
         if (line.trim() === '') {
             return;
         }
+
         let entry: unknown;
+
         try {
             entry = JSON.parse(line);
         } catch {
             return;
         }
+
         if (!isRecord(entry) || (entry.type !== 'user' && entry.type !== 'assistant')) {
             return;
         }
+
         const time = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : Number.NaN;
+
         if (Number.isFinite(time)) {
             this.lineTime = time;
         }
+
         const message = isRecord(entry.message) ? entry.message : {};
         const said = entry.type === 'user' ? spokenText(message.content) : null;
+
         if (said !== null) {
             // The prompt it was given, or a message sent to it later; a reminder the CLI slipped in is not somebody talking.
             if (entry.isMeta !== true && said.trim() !== '') {
@@ -244,8 +285,10 @@ export class TranscriptProjection {
                     text: said
                 });
             }
+
             return;
         }
+
         for (const event of this.protocol.handle({ type: entry.type, message })) {
             this.projector.project(0, event);
         }