psadk 1.4.8 → 1.5.1

package/build/main/lib/agent-core/src/harness/session/jsonl-storage.js

@@ -0,0 +1,234 @@
+import { SessionError, toError } from "../types.js";
+import { getFileSystemResultOrThrow } from "./repo-utils.js";
+import { uuidv7 } from "./uuid.js";
+function updateLabelCache(labelsById, entry) {
+    if (entry.type !== 'label')
+        return;
+    const label = entry.label?.trim();
+    if (label) {
+        labelsById.set(entry.targetId, label);
+    }
+    else {
+        labelsById.delete(entry.targetId);
+    }
+}
+function buildLabelsById(entries) {
+    const labelsById = new Map();
+    for (const entry of entries) {
+        updateLabelCache(labelsById, entry);
+    }
+    return labelsById;
+}
+function generateEntryId(byId) {
+    for (let i = 0; i < 100; i++) {
+        const id = uuidv7().slice(0, 8);
+        if (!byId.has(id))
+            return id;
+    }
+    return uuidv7();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function invalidSession(filePath, message, cause) {
+    return new SessionError('invalid_session', `Invalid JSONL session file ${filePath}: ${message}`, cause);
+}
+function invalidEntry(filePath, lineNumber, message, cause) {
+    return new SessionError('invalid_entry', `Invalid JSONL session file ${filePath}: line ${lineNumber} ${message}`, cause);
+}
+function parseHeaderLine(line, filePath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        throw invalidSession(filePath, 'first line is not a valid session header', toError(error));
+    }
+    if (!isRecord(parsed))
+        throw invalidSession(filePath, 'first line is not a valid session header');
+    if (parsed.type !== 'session')
+        throw invalidSession(filePath, 'first line is not a valid session header');
+    if (parsed.version !== 3)
+        throw invalidSession(filePath, 'unsupported session version');
+    if (typeof parsed.id !== 'string' || !parsed.id)
+        throw invalidSession(filePath, 'session header is missing id');
+    if (typeof parsed.timestamp !== 'string' || !parsed.timestamp) {
+        throw invalidSession(filePath, 'session header is missing timestamp');
+    }
+    if (typeof parsed.cwd !== 'string' || !parsed.cwd)
+        throw invalidSession(filePath, 'session header is missing cwd');
+    if (parsed.parentSession !== undefined &&
+        typeof parsed.parentSession !== 'string') {
+        throw invalidSession(filePath, 'session header parentSession must be a string');
+    }
+    return {
+        type: 'session',
+        version: 3,
+        id: parsed.id,
+        timestamp: parsed.timestamp,
+        cwd: parsed.cwd,
+        parentSession: parsed.parentSession,
+    };
+}
+function parseEntryLine(line, filePath, lineNumber) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        throw invalidEntry(filePath, lineNumber, 'is not valid JSON', toError(error));
+    }
+    if (!isRecord(parsed))
+        throw invalidEntry(filePath, lineNumber, 'is not a valid session entry');
+    if (typeof parsed.type !== 'string')
+        throw invalidEntry(filePath, lineNumber, 'is missing entry type');
+    if (typeof parsed.id !== 'string' || !parsed.id)
+        throw invalidEntry(filePath, lineNumber, 'is missing entry id');
+    if (parsed.parentId !== null && typeof parsed.parentId !== 'string') {
+        throw invalidEntry(filePath, lineNumber, 'has invalid parentId');
+    }
+    if (typeof parsed.timestamp !== 'string' || !parsed.timestamp) {
+        throw invalidEntry(filePath, lineNumber, 'is missing timestamp');
+    }
+    if (parsed.type === 'leaf' &&
+        parsed.targetId !== null &&
+        typeof parsed.targetId !== 'string') {
+        throw invalidEntry(filePath, lineNumber, 'has invalid targetId');
+    }
+    return parsed;
+}
+function leafIdAfterEntry(entry) {
+    return entry.type === 'leaf' ? entry.targetId : entry.id;
+}
+function headerToSessionMetadata(header, path) {
+    return {
+        id: header.id,
+        createdAt: header.timestamp,
+        cwd: header.cwd,
+        path,
+        parentSessionPath: header.parentSession,
+    };
+}
+export async function loadJsonlSessionMetadata(fs, filePath) {
+    const lines = getFileSystemResultOrThrow(await fs.readTextLines(filePath, { maxLines: 1 }), `Failed to read session header ${filePath}`);
+    const line = lines[0];
+    if (line?.trim())
+        return headerToSessionMetadata(parseHeaderLine(line, filePath), filePath);
+    throw invalidSession(filePath, 'missing session header');
+}
+async function loadJsonlStorage(fs, filePath) {
+    const content = getFileSystemResultOrThrow(await fs.readTextFile(filePath), `Failed to read session ${filePath}`);
+    const lines = content.split('\n').filter((line) => line.trim());
+    if (lines.length === 0) {
+        throw invalidSession(filePath, 'missing session header');
+    }
+    const header = parseHeaderLine(lines[0], filePath);
+    const entries = [];
+    let leafId = null;
+    for (let i = 1; i < lines.length; i++) {
+        const entry = parseEntryLine(lines[i], filePath, i + 1);
+        entries.push(entry);
+        leafId = leafIdAfterEntry(entry);
+    }
+    return { header, entries, leafId };
+}
+export class JsonlSessionStorage {
+    fs;
+    filePath;
+    metadata;
+    entries;
+    byId;
+    labelsById;
+    currentLeafId;
+    constructor(fs, filePath, header, entries, leafId) {
+        this.fs = fs;
+        this.filePath = filePath;
+        this.metadata = headerToSessionMetadata(header, this.filePath);
+        this.entries = entries;
+        this.byId = new Map(entries.map((entry) => [entry.id, entry]));
+        this.labelsById = buildLabelsById(entries);
+        this.currentLeafId = leafId;
+    }
+    static async open(fs, filePath) {
+        const loaded = await loadJsonlStorage(fs, filePath);
+        return new JsonlSessionStorage(fs, filePath, loaded.header, loaded.entries, loaded.leafId);
+    }
+    static async create(fs, filePath, options) {
+        const header = {
+            type: 'session',
+            version: 3,
+            id: options.sessionId,
+            timestamp: new Date().toISOString(),
+            cwd: options.cwd,
+            parentSession: options.parentSessionPath,
+        };
+        getFileSystemResultOrThrow(await fs.writeFile(filePath, `${JSON.stringify(header)}\n`), `Failed to create session ${filePath}`);
+        return new JsonlSessionStorage(fs, filePath, header, [], null);
+    }
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getLeafId() {
+        if (this.currentLeafId !== null && !this.byId.has(this.currentLeafId)) {
+            throw new SessionError('invalid_session', `Entry ${this.currentLeafId} not found`);
+        }
+        return this.currentLeafId;
+    }
+    async setLeafId(leafId) {
+        if (leafId !== null && !this.byId.has(leafId)) {
+            throw new SessionError('not_found', `Entry ${leafId} not found`);
+        }
+        const entry = {
+            type: 'leaf',
+            id: generateEntryId(this.byId),
+            parentId: this.currentLeafId,
+            timestamp: new Date().toISOString(),
+            targetId: leafId,
+        };
+        getFileSystemResultOrThrow(await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`), `Failed to append session leaf ${entry.id}`);
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        this.currentLeafId = leafId;
+    }
+    async createEntryId() {
+        return generateEntryId(this.byId);
+    }
+    async appendEntry(entry) {
+        getFileSystemResultOrThrow(await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`), `Failed to append session entry ${entry.id}`);
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        updateLabelCache(this.labelsById, entry);
+        this.currentLeafId = leafIdAfterEntry(entry);
+    }
+    async getEntry(id) {
+        return this.byId.get(id);
+    }
+    async findEntries(type) {
+        return this.entries.filter((entry) => entry.type === type);
+    }
+    async getLabel(id) {
+        return this.labelsById.get(id);
+    }
+    async getPathToRoot(leafId) {
+        if (leafId === null)
+            return [];
+        const path = [];
+        let current = this.byId.get(leafId);
+        if (!current)
+            throw new SessionError('not_found', `Entry ${leafId} not found`);
+        while (current) {
+            path.unshift(current);
+            if (!current.parentId)
+                break;
+            const parent = this.byId.get(current.parentId);
+            if (!parent)
+                throw new SessionError('invalid_session', `Entry ${current.parentId} not found`);
+            current = parent;
+        }
+        return path;
+    }
+    async getEntries() {
+        return [...this.entries];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsonl-storage.js","sourceRoot":"","sources":["../../../../../../../src/lib/agent-core/src/harness/session/jsonl-storage.ts"],"names":[],"mappings":"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"}

package/build/main/lib/agent-core/{harness/session/repo/memory.d.ts → src/harness/session/memory-repo.d.ts}

@@ -1,4 +1,4 @@
-import type { Session, SessionMetadata, SessionRepo } from '../../types.js';
+import { type Session, type SessionMetadata, type SessionRepo } from '../types.ts';
 export declare class InMemorySessionRepo implements SessionRepo<SessionMetadata, {
     id?: string;
 }, void> {

package/build/main/lib/agent-core/src/harness/session/memory-repo.js

@@ -0,0 +1,45 @@
+import { SessionError, } from "../types.js";
+import { InMemorySessionStorage } from "./memory-storage.js";
+import { createSessionId, createTimestamp, getEntriesToFork, toSession, } from "./repo-utils.js";
+export class InMemorySessionRepo {
+    sessions = new Map();
+    async create(options = {}) {
+        const metadata = {
+            id: options.id ?? createSessionId(),
+            createdAt: createTimestamp(),
+        };
+        const storage = new InMemorySessionStorage({ metadata });
+        const session = toSession(storage);
+        this.sessions.set(metadata.id, session);
+        return session;
+    }
+    async open(metadata) {
+        const session = this.sessions.get(metadata.id);
+        if (!session) {
+            throw new SessionError('not_found', `Session not found: ${metadata.id}`);
+        }
+        return session;
+    }
+    async list() {
+        return Promise.all([...this.sessions.values()].map((session) => session.getMetadata()));
+    }
+    async delete(metadata) {
+        this.sessions.delete(metadata.id);
+    }
+    async fork(sourceMetadata, options) {
+        const source = await this.open(sourceMetadata);
+        const forkedEntries = await getEntriesToFork(source.getStorage(), options);
+        const metadata = {
+            id: options.id ?? createSessionId(),
+            createdAt: createTimestamp(),
+        };
+        const storage = new InMemorySessionStorage({
+            metadata,
+            entries: forkedEntries,
+        });
+        const session = toSession(storage);
+        this.sessions.set(metadata.id, session);
+        return session;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/agent-core/{harness/session/storage/memory.d.ts → src/harness/session/memory-storage.d.ts}

@@ -1,5 +1,5 @@
-import type { SessionMetadata, SessionStorage, SessionTreeEntry } from '../../types.js';
-export declare class InMemorySessionStorage implements SessionStorage {
+import { type SessionMetadata, type SessionStorage, type SessionTreeEntry } from '../types.ts';
+export declare class InMemorySessionStorage<TMetadata extends SessionMetadata = SessionMetadata> implements SessionStorage<TMetadata> {
     private readonly metadata;
     private entries;
     private byId;
@@ -7,10 +7,9 @@ export declare class InMemorySessionStorage implements SessionStorage {
     private leafId;
     constructor(options?: {
         entries?: SessionTreeEntry[];
-        leafId?: string | null;
-        metadata?: SessionMetadata;
+        metadata?: TMetadata;
     });
-    getMetadata(): Promise<SessionMetadata>;
+    getMetadata(): Promise<TMetadata>;
     getLeafId(): Promise<string | null>;
     setLeafId(leafId: string | null): Promise<void>;
     createEntryId(): Promise<string>;

package/build/main/lib/agent-core/src/harness/session/memory-storage.js

@@ -0,0 +1,116 @@
+import { SessionError, } from "../types.js";
+import { uuidv7 } from "./uuid.js";
+function updateLabelCache(labelsById, entry) {
+    if (entry.type !== 'label')
+        return;
+    const label = entry.label?.trim();
+    if (label) {
+        labelsById.set(entry.targetId, label);
+    }
+    else {
+        labelsById.delete(entry.targetId);
+    }
+}
+function buildLabelsById(entries) {
+    const labelsById = new Map();
+    for (const entry of entries) {
+        updateLabelCache(labelsById, entry);
+    }
+    return labelsById;
+}
+function generateEntryId(byId) {
+    for (let i = 0; i < 100; i++) {
+        const id = uuidv7().slice(0, 8);
+        if (!byId.has(id))
+            return id;
+    }
+    return uuidv7();
+}
+function leafIdAfterEntry(entry) {
+    return entry.type === 'leaf' ? entry.targetId : entry.id;
+}
+export class InMemorySessionStorage {
+    metadata;
+    entries;
+    byId;
+    labelsById;
+    leafId;
+    constructor(options) {
+        this.entries = options?.entries ? [...options.entries] : [];
+        this.byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+        this.labelsById = buildLabelsById(this.entries);
+        this.leafId = null;
+        for (const entry of this.entries)
+            this.leafId = leafIdAfterEntry(entry);
+        if (this.leafId !== null && !this.byId.has(this.leafId)) {
+            throw new SessionError('invalid_session', `Entry ${this.leafId} not found`);
+        }
+        this.metadata =
+            options?.metadata ??
+                { id: uuidv7(), createdAt: new Date().toISOString() };
+    }
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getLeafId() {
+        if (this.leafId !== null && !this.byId.has(this.leafId)) {
+            throw new SessionError('invalid_session', `Entry ${this.leafId} not found`);
+        }
+        return this.leafId;
+    }
+    async setLeafId(leafId) {
+        if (leafId !== null && !this.byId.has(leafId)) {
+            throw new SessionError('not_found', `Entry ${leafId} not found`);
+        }
+        const entry = {
+            type: 'leaf',
+            id: generateEntryId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            targetId: leafId,
+        };
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        this.leafId = leafId;
+    }
+    async createEntryId() {
+        return generateEntryId(this.byId);
+    }
+    async appendEntry(entry) {
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        updateLabelCache(this.labelsById, entry);
+        this.leafId = leafIdAfterEntry(entry);
+    }
+    async getEntry(id) {
+        return this.byId.get(id);
+    }
+    async findEntries(type) {
+        return this.entries.filter((entry) => entry.type === type);
+    }
+    async getLabel(id) {
+        return this.labelsById.get(id);
+    }
+    async getPathToRoot(leafId) {
+        if (leafId === null)
+            return [];
+        const path = [];
+        let current = this.byId.get(leafId);
+        if (!current)
+            throw new SessionError('not_found', `Entry ${leafId} not found`);
+        while (current) {
+            path.unshift(current);
+            if (!current.parentId)
+                break;
+            const parent = this.byId.get(current.parentId);
+            if (!parent)
+                throw new SessionError('invalid_session', `Entry ${current.parentId} not found`);
+            current = parent;
+        }
+        return path;
+    }
+    async getEntries() {
+        return [...this.entries];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/agent-core/{harness/session/repo/shared.d.ts → src/harness/session/repo-utils.d.ts}

@@ -1,8 +1,9 @@
-import type { SessionMetadata, SessionStorage, SessionTreeEntry } from '../../types.js';
-import { Session } from '../session.js';
+import { type FileError, type Result, type SessionMetadata, type SessionStorage, type SessionTreeEntry } from '../types.ts';
+import { Session } from './session.ts';
 export declare function createSessionId(): string;
 export declare function createTimestamp(): string;
 export declare function toSession<TMetadata extends SessionMetadata>(storage: SessionStorage<TMetadata>): Session<TMetadata>;
+export declare function getFileSystemResultOrThrow<TValue>(result: Result<TValue, FileError>, message: string): TValue;
 export declare function getEntriesToFork(storage: SessionStorage, options: {
     entryId?: string;
     position?: 'before' | 'at';

package/build/main/lib/agent-core/src/harness/session/repo-utils.js

@@ -0,0 +1,39 @@
+import { SessionError, } from "../types.js";
+import { Session } from "./session.js";
+import { uuidv7 } from "./uuid.js";
+export function createSessionId() {
+    return uuidv7();
+}
+export function createTimestamp() {
+    return new Date().toISOString();
+}
+export function toSession(storage) {
+    return new Session(storage);
+}
+export function getFileSystemResultOrThrow(result, message) {
+    if (!result.ok) {
+        const code = result.error.code === 'not_found' ? 'not_found' : 'storage';
+        throw new SessionError(code, `${message}: ${result.error.message}`, result.error);
+    }
+    return result.value;
+}
+export async function getEntriesToFork(storage, options) {
+    if (!options.entryId)
+        return storage.getEntries();
+    const target = await storage.getEntry(options.entryId);
+    if (!target) {
+        throw new SessionError('invalid_fork_target', `Entry ${options.entryId} not found`);
+    }
+    let effectiveLeafId;
+    if ((options.position ?? 'before') === 'at') {
+        effectiveLeafId = target.id;
+    }
+    else {
+        if (target.type !== 'message' || target.message.role !== 'user') {
+            throw new SessionError('invalid_fork_target', `Entry ${options.entryId} is not a user message`);
+        }
+        effectiveLeafId = target.parentId;
+    }
+    return storage.getPathToRoot(effectiveLeafId);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/{module/lib/agent-core → main/lib/agent-core/src}/harness/session/session.d.ts

@@ -1,6 +1,6 @@
 import type { ImageContent, TextContent } from '@earendil-works/pi-ai';
-import type { AgentMessage } from '../../types.js';
-import type { SessionContext, SessionMetadata, SessionStorage, SessionTreeEntry } from '../types.js';
+import type { AgentMessage } from '../../types.ts';
+import type { SessionContext, SessionMetadata, SessionStorage, SessionTreeEntry } from '../types.ts';
 export declare function buildSessionContext(pathEntries: SessionTreeEntry[]): SessionContext;
 export declare class Session<TMetadata extends SessionMetadata = SessionMetadata> {
     private storage;
@@ -18,6 +18,7 @@ export declare class Session<TMetadata extends SessionMetadata = SessionMetadata
     appendMessage(message: AgentMessage): Promise<string>;
     appendThinkingLevelChange(thinkingLevel: string): Promise<string>;
     appendModelChange(provider: string, modelId: string): Promise<string>;
+    appendActiveToolsChange(activeToolNames: string[]): Promise<string>;
     appendCompaction<T = unknown>(summary: string, firstKeptEntryId: string, tokensBefore: number, details?: T, fromHook?: boolean): Promise<string>;
     appendCustomEntry(customType: string, data?: unknown): Promise<string>;
     appendCustomMessageEntry<T = unknown>(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details?: T): Promise<string>;