@adecore/agents 0.0.1 → 0.17.0-beta.1

package/dist/chat/claude-title.js

@@ -0,0 +1,97 @@
+import { existsSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { usageRoots } from '../usage/roots.js';
+import { cleanTitle, readLines } from '../title-file.js';
+// The two records carry these words; a line without them is never parsed.
+const MARKERS = ['"ai-title"', '"custom-title"'];
+/*
+ * The name Claude Code gave a session, out of its own transcript. It writes an `ai-title` record a
+ * few seconds after the first prompt, anywhere in the file and more than once, and a `custom-title`
+ * when a person ran /rename in the CLI, which wins because a person chose it. A transcript only ever
+ * grows, so each path is read from where the previous read stopped: a file of many megabytes costs
+ * its full read once, and every read after that only the lines added since.
+ */
+export class ClaudeTitleReader {
+    progress = new Map();
+    found = new Map();
+    projectsDir;
+    chunkBytes;
+    constructor(projectsDir = usageRoots().find((root) => root.provider === 'claude')?.path ?? '', chunkBytes = 4 * 1024 * 1024) {
+        this.projectsDir = projectsDir;
+        this.chunkBytes = chunkBytes;
+    }
+    /* The title of a session found by its id, for a chat, which knows no transcript path; in the projects of its account. */
+    async forSession(agentSessionId, projectsDir = this.projectsDir) {
+        const path = await this.locate(agentSessionId, projectsDir);
+        return path === null ? null : await this.forTranscript(path);
+    }
+    async forTranscript(path) {
+        let size;
+        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;
+    }
+    take(line, progress) {
+        if (!MARKERS.some((marker) => line.includes(marker))) {
+            return;
+        }
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof record !== 'object' || record === null) {
+            return;
+        }
+        const entry = record;
+        if (entry.type === 'ai-title') {
+            progress.aiTitle = cleanTitle(entry.aiTitle) ?? progress.aiTitle;
+        }
+        else if (entry.type === 'custom-title') {
+            progress.customTitle = cleanTitle(entry.customTitle) ?? progress.customTitle;
+        }
+    }
+    /* The folder a transcript sits in is named after the working directory, so the file name is the only key a session id gives. */
+    async locate(agentSessionId, projectsDir) {
+        const known = this.found.get(agentSessionId);
+        if (known !== undefined && existsSync(known)) {
+            return known;
+        }
+        if (projectsDir === '' || agentSessionId.includes('/')) {
+            return null;
+        }
+        let dirs;
+        try {
+            dirs = await readdir(projectsDir);
+        }
+        catch {
+            return null;
+        }
+        const file = `${agentSessionId}.jsonl`;
+        for (const dir of dirs) {
+            const path = join(projectsDir, dir, file);
+            if (existsSync(path)) {
+                this.found.set(agentSessionId, path);
+                return path;
+            }
+        }
+        return null;
+    }
+}

package/dist/chat/claude-transcript.d.ts

@@ -0,0 +1,28 @@
+import type { ChatHistoryResult, ChatItem } from '@adecore/agent-contracts';
+export interface SubagentMeta {
+    agentId: string;
+    toolUseId: string | null;
+    parentAgentId: string | null;
+    description: string | null;
+    transcript: string;
+}
+export declare function claudeProjectSlug(cwd: string): string;
+export declare function findSubagentsDir(projectsDir: string, cwd: string, sessionId: string): Promise<string | null>;
+export declare function readSubagentMetas(dir: string): Promise<SubagentMeta[]>;
+export declare function findWorkflowAgent(subagentsDir: string, agentId: string): Promise<SubagentMeta | null>;
+export declare class TranscriptProjection {
+    readonly path: string;
+    private thread;
+    private projector;
+    private protocol;
+    private offset;
+    private size;
+    private mtimeMs;
+    private lineTime;
+    constructor(path: string);
+    refresh(): Promise<boolean>;
+    items(): ChatItem[];
+    page(limit: number, cursor?: string): ChatHistoryResult;
+    private reset;
+    private take;
+}

package/dist/chat/claude-transcript.js

@@ -0,0 +1,211 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readLines } from '../title-file.js';
+import { ClaudeProtocol } from './claude-protocol.js';
+import { readingThread, settledReading } from './subagent-projection.js';
+const CHUNK_BYTES = 4 * 1024 * 1024;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function str(value) {
+    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. */
+function spokenText(content) {
+    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.text ?? ''));
+    return texts.length === 0 ? null : texts.join('\n');
+}
+/* The folder name Claude Code gives a working directory: every character that is not a letter or a digit becomes a dash. */
+export function claudeProjectSlug(cwd) {
+    return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+/*
+ * Where the subagents of a session keep their transcripts. The folder of the chat's own directory
+ * first; a slug the CLI wrote differently (or a session resumed from somewhere else) is found by the
+ * session id alone, which is unique across every project.
+ */
+export async function findSubagentsDir(projectsDir, cwd, sessionId) {
+    if (projectsDir === '' || sessionId.includes('/') || sessionId.includes('..')) {
+        return null;
+    }
+    const own = join(projectsDir, claudeProjectSlug(cwd), sessionId, 'subagents');
+    if (existsSync(own)) {
+        return own;
+    }
+    let dirs;
+    try {
+        dirs = await readdir(projectsDir);
+    }
+    catch {
+        return null;
+    }
+    for (const dir of dirs) {
+        const candidate = join(projectsDir, dir, sessionId, 'subagents');
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return 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) {
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const metas = [];
+    for (const name of names) {
+        const match = /^agent-(.+)\.meta\.json$/.exec(name);
+        if (!match) {
+            continue;
+        }
+        let parsed;
+        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),
+            parentAgentId: str(parsed.parentAgentId),
+            description: str(parsed.description),
+            transcript: join(dir, `agent-${agentId}.jsonl`)
+        });
+    }
+    return metas;
+}
+/*
+ * The transcript of one agent a workflow started. Claude Code 2.1.282 keeps a folder per run under
+ * `workflows` in the subagents folder, and nothing but the agent id ties an agent to its run.
+ */
+export async function findWorkflowAgent(subagentsDir, agentId) {
+    if (!/^[\w-]+$/.test(agentId)) {
+        return null;
+    }
+    const workflowsDir = join(subagentsDir, 'workflows');
+    let runs;
+    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;
+}
+/*
+ * One subagent transcript as thread items, read on from where the last read stopped: a transcript only
+ * grows, and a panel that follows a working agent asks again every time a line lands. The lines have
+ * the envelope of the main transcript, so an assistant or a tool result goes through the same mapping
+ * the live stream does. A file that shrank or was rewritten is read again from the start under a new
+ * thread, whose cursors then no longer match, so a client holding one is told the history expired.
+ */
+export class TranscriptProjection {
+    path;
+    thread;
+    projector;
+    protocol;
+    offset = 0;
+    size = 0;
+    mtimeMs = 0;
+    lineTime = 0;
+    constructor(path) {
+        this.path = path;
+        this.reset();
+    }
+    /* Reads what was added since the last call; false when the file is not there. */
+    async refresh() {
+        let info;
+        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;
+    }
+    items() {
+        return this.thread.list().map(settledReading);
+    }
+    /* The page before `cursor`, or the newest page without one; the cursors are the thread's own. */
+    page(limit, cursor) {
+        const page = this.thread.history(limit, cursor);
+        return { items: page.items.map(settledReading), history: page.history };
+    }
+    reset() {
+        const reading = readingThread('Claude', () => this.lineTime);
+        this.thread = reading.thread;
+        this.projector = reading.projector;
+        this.protocol = new ClaudeProtocol();
+        this.offset = 0;
+        this.size = 0;
+        this.mtimeMs = 0;
+    }
+    take(line) {
+        if (line.trim() === '') {
+            return;
+        }
+        let entry;
+        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() !== '') {
+                this.thread.upsert({
+                    id: `user-${str(entry.uuid) ?? this.thread.list().length}`,
+                    kind: 'user',
+                    createdAt: this.lineTime,
+                    turnId: null,
+                    text: said
+                });
+            }
+            return;
+        }
+        for (const event of this.protocol.handle({ type: entry.type, message })) {
+            this.projector.project(0, event);
+        }
+    }
+}

package/dist/chat/codex-backend.d.ts

@@ -0,0 +1,51 @@
+import { type ChatSkill } from '@adecore/agent-contracts';
+import type { ApprovalDecision, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
+import { type CodexClientInfo } from './codex-transport.ts';
+export declare function parseSkillsList(result: unknown): ChatSkill[];
+export interface CodexBackendOptions {
+    client?: CodexClientInfo;
+}
+export declare class CodexBackend implements ChatBackend {
+    readonly acknowledgesTurns = true;
+    private promptId;
+    private readonly launch;
+    private readonly host;
+    private readonly protocol;
+    private readonly client;
+    private transport;
+    private threadId;
+    private contextPending;
+    private imageInputSupported;
+    private turnUnnamed;
+    private interruptOwed;
+    constructor(launch: BackendLaunch, host: BackendHost, options?: CodexBackendOptions);
+    get running(): boolean;
+    get pid(): number | null;
+    start(): Promise<void>;
+    sendTurn(input: TurnInput): void;
+    private acceptPrompt;
+    private fail;
+    private respond;
+    private readImageSupport;
+    compact(): void;
+    setTitle(title: string): void;
+    listSkills(): Promise<ChatSkill[]>;
+    listThreadItems(params: {
+        threadId: string;
+        cursor?: string;
+        limit: number;
+        sortDirection: 'asc' | 'desc';
+    }): Promise<unknown>;
+    interrupt(): void;
+    stopTask(taskId: string): void;
+    respondApproval(requestId: string, decision: ApprovalDecision): boolean;
+    respondQuestion(requestId: string, answers: Record<string, string>): boolean;
+    dismissRequest(requestId: string): boolean;
+    declineRequest(requestId: string, _message: string): boolean;
+    stop(): void;
+    dispose(): Promise<void>;
+    private request;
+    private handleFrame;
+    private handleExit;
+    private emit;
+}