@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-1

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/repo/jsonl.js

@@ -0,0 +1,92 @@
+import { constants } from "node:fs";
+import { access, mkdir, readdir, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { JsonlSessionStorage, loadJsonlSessionMetadata } from "../storage/jsonl.js";
+import { createSessionId, createTimestamp, getEntriesToFork, toSession } from "./shared.js";
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function encodeCwd(cwd) {
+    return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+export class JsonlSessionRepo {
+    sessionsRoot;
+    constructor(options) {
+        this.sessionsRoot = resolve(options.sessionsRoot);
+    }
+    getSessionDir(cwd) {
+        return join(this.sessionsRoot, encodeCwd(cwd));
+    }
+    createSessionFilePath(cwd, sessionId, timestamp) {
+        return join(this.getSessionDir(cwd), `${timestamp.replace(/[:.]/g, "-")}_${sessionId}.jsonl`);
+    }
+    async create(options) {
+        await mkdir(this.sessionsRoot, { recursive: true });
+        const id = options.id ?? createSessionId();
+        const createdAt = createTimestamp();
+        const filePath = this.createSessionFilePath(options.cwd, id, createdAt);
+        const storage = await JsonlSessionStorage.create(filePath, {
+            cwd: options.cwd,
+            sessionId: id,
+            parentSessionPath: options.parentSessionPath,
+        });
+        return toSession(storage);
+    }
+    async open(metadata) {
+        if (!(await exists(metadata.path))) {
+            throw new Error(`Session not found: ${metadata.path}`);
+        }
+        const storage = await JsonlSessionStorage.open(metadata.path);
+        return toSession(storage);
+    }
+    async list(options = {}) {
+        const dirs = options.cwd ? [this.getSessionDir(options.cwd)] : await this.listSessionDirs();
+        const sessions = [];
+        for (const dir of dirs) {
+            if (!(await exists(dir)))
+                continue;
+            const files = (await readdir(dir)).filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
+            for (const filePath of files) {
+                try {
+                    sessions.push(await loadJsonlSessionMetadata(filePath));
+                }
+                catch {
+                    // Ignore invalid session files when listing a directory.
+                }
+            }
+        }
+        sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        return sessions;
+    }
+    async delete(metadata) {
+        await rm(metadata.path, { force: true });
+    }
+    async fork(sourceMetadata, options) {
+        const source = await this.open(sourceMetadata);
+        const forkedEntries = await getEntriesToFork(source.getStorage(), options);
+        const id = options.id ?? createSessionId();
+        const createdAt = createTimestamp();
+        const storage = await JsonlSessionStorage.create(this.createSessionFilePath(options.cwd, id, createdAt), {
+            cwd: options.cwd,
+            sessionId: id,
+            parentSessionPath: options.parentSessionPath ?? sourceMetadata.path,
+        });
+        for (const entry of forkedEntries) {
+            await storage.appendEntry(entry);
+        }
+        return toSession(storage);
+    }
+    async listSessionDirs() {
+        if (!(await exists(this.sessionsRoot)))
+            return [];
+        const entries = await readdir(this.sessionsRoot, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => join(this.sessionsRoot, entry.name));
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/repo/memory.js

@@ -0,0 +1,42 @@
+import { InMemorySessionStorage } from "../storage/memory.js";
+import { createSessionId, createTimestamp, getEntriesToFork, toSession } from "./shared.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 Error(`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 leafId = forkedEntries[forkedEntries.length - 1]?.id ?? null;
+        const storage = new InMemorySessionStorage({ metadata, entries: forkedEntries, leafId });
+        const session = toSession(storage);
+        this.sessions.set(metadata.id, session);
+        return session;
+    }
+}
+//# sourceMappingURL=memory.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/repo/shared.js

@@ -0,0 +1,31 @@
+import { v7 as uuidv7 } from "uuid";
+import { Session } from "../session.js";
+export function createSessionId() {
+    return uuidv7();
+}
+export function createTimestamp() {
+    return new Date().toISOString();
+}
+export function toSession(storage) {
+    return new Session(storage);
+}
+export async function getEntriesToFork(storage, options) {
+    if (!options.entryId)
+        return storage.getEntries();
+    const target = await storage.getEntry(options.entryId);
+    if (!target) {
+        throw new Error(`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 Error(`Entry ${options.entryId} is not a user message`);
+        }
+        effectiveLeafId = target.parentId;
+    }
+    return storage.getPathToRoot(effectiveLeafId);
+}
+//# sourceMappingURL=shared.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/session.js

@@ -0,0 +1,196 @@
+import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage } from "../messages.js";
+export function buildSessionContext(pathEntries) {
+    let thinkingLevel = "off";
+    let model = null;
+    let compaction = null;
+    for (const entry of pathEntries) {
+        if (entry.type === "thinking_level_change") {
+            thinkingLevel = entry.thinkingLevel;
+        }
+        else if (entry.type === "model_change") {
+            model = { provider: entry.provider, modelId: entry.modelId };
+        }
+        else if (entry.type === "message" && entry.message.role === "assistant") {
+            model = { provider: entry.message.provider, modelId: entry.message.model };
+        }
+        else if (entry.type === "compaction") {
+            compaction = entry;
+        }
+    }
+    const messages = [];
+    const appendMessage = (entry) => {
+        if (entry.type === "message") {
+            messages.push(entry.message);
+        }
+        else if (entry.type === "custom_message") {
+            messages.push(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
+        }
+        else if (entry.type === "branch_summary" && entry.summary) {
+            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+        }
+    };
+    if (compaction) {
+        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
+        const compactionIdx = pathEntries.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
+        let foundFirstKept = false;
+        for (let i = 0; i < compactionIdx; i++) {
+            const entry = pathEntries[i];
+            if (entry.id === compaction.firstKeptEntryId)
+                foundFirstKept = true;
+            if (foundFirstKept)
+                appendMessage(entry);
+        }
+        for (let i = compactionIdx + 1; i < pathEntries.length; i++) {
+            appendMessage(pathEntries[i]);
+        }
+    }
+    else {
+        for (const entry of pathEntries) {
+            appendMessage(entry);
+        }
+    }
+    return { messages, thinkingLevel, model };
+}
+export class Session {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    getMetadata() {
+        return this.storage.getMetadata();
+    }
+    getStorage() {
+        return this.storage;
+    }
+    getLeafId() {
+        return this.storage.getLeafId();
+    }
+    getEntry(id) {
+        return this.storage.getEntry(id);
+    }
+    getEntries() {
+        return this.storage.getEntries();
+    }
+    async getBranch(fromId) {
+        const leafId = fromId ?? (await this.storage.getLeafId());
+        return this.storage.getPathToRoot(leafId);
+    }
+    async buildContext() {
+        return buildSessionContext(await this.getBranch());
+    }
+    getLabel(id) {
+        return this.storage.getLabel(id);
+    }
+    async getSessionName() {
+        const entries = await this.storage.findEntries("session_info");
+        return entries[entries.length - 1]?.name?.trim() || undefined;
+    }
+    async appendTypedEntry(entry) {
+        await this.storage.appendEntry(entry);
+        return entry.id;
+    }
+    async appendMessage(message) {
+        return this.appendTypedEntry({
+            type: "message",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            message,
+        });
+    }
+    async appendThinkingLevelChange(thinkingLevel) {
+        return this.appendTypedEntry({
+            type: "thinking_level_change",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            thinkingLevel,
+        });
+    }
+    async appendModelChange(provider, modelId) {
+        return this.appendTypedEntry({
+            type: "model_change",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            provider,
+            modelId,
+        });
+    }
+    async appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+        return this.appendTypedEntry({
+            type: "compaction",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            summary,
+            firstKeptEntryId,
+            tokensBefore,
+            details,
+            fromHook,
+        });
+    }
+    async appendCustomEntry(customType, data) {
+        return this.appendTypedEntry({
+            type: "custom",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            customType,
+            data,
+        });
+    }
+    async appendCustomMessageEntry(customType, content, display, details) {
+        return this.appendTypedEntry({
+            type: "custom_message",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            customType,
+            content,
+            display,
+            details,
+        });
+    }
+    async appendLabel(targetId, label) {
+        if (!(await this.storage.getEntry(targetId))) {
+            throw new Error(`Entry ${targetId} not found`);
+        }
+        return this.appendTypedEntry({
+            type: "label",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            targetId,
+            label,
+        });
+    }
+    async appendSessionName(name) {
+        return this.appendTypedEntry({
+            type: "session_info",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            name: name.trim(),
+        });
+    }
+    async moveTo(entryId, summary) {
+        if (entryId !== null && !(await this.storage.getEntry(entryId))) {
+            throw new Error(`Entry ${entryId} not found`);
+        }
+        await this.storage.setLeafId(entryId);
+        if (!summary)
+            return undefined;
+        return this.appendTypedEntry({
+            type: "branch_summary",
+            id: await this.storage.createEntryId(),
+            parentId: entryId,
+            timestamp: new Date().toISOString(),
+            fromId: entryId ?? "root",
+            summary: summary.summary,
+            details: summary.details,
+            fromHook: summary.fromHook,
+        });
+    }
+}
+//# sourceMappingURL=session.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/storage/jsonl.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createInterface } from "node:readline";
+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 = randomUUID().slice(0, 8);
+        if (!byId.has(id))
+            return id;
+    }
+    return randomUUID();
+}
+function headerToSessionMetadata(header, path) {
+    return {
+        id: header.id,
+        createdAt: header.timestamp,
+        cwd: header.cwd,
+        path,
+        parentSessionPath: header.parentSession,
+    };
+}
+export async function loadJsonlSessionMetadata(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+        for await (const line of lines) {
+            if (!line.trim())
+                break;
+            try {
+                const header = JSON.parse(line);
+                return headerToSessionMetadata(header, resolve(filePath));
+            }
+            catch {
+                throw new Error(`Invalid JSONL session file ${filePath}: first line is not a valid session header`);
+            }
+        }
+        throw new Error(`Invalid JSONL session file ${filePath}: missing session header`);
+    }
+    finally {
+        lines.close();
+        stream.destroy();
+    }
+}
+async function loadJsonlStorage(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const lines = content.split("\n").filter((line) => line.trim());
+    if (lines.length === 0) {
+        throw new Error(`Invalid JSONL session file ${filePath}: missing session header`);
+    }
+    let header;
+    try {
+        header = JSON.parse(lines[0]);
+    }
+    catch {
+        throw new Error(`Invalid JSONL session file ${filePath}: first line is not a valid session header`);
+    }
+    const entries = [];
+    let leafId = null;
+    for (const line of lines.slice(1)) {
+        try {
+            const entry = JSON.parse(line);
+            entries.push(entry);
+            leafId = entry.id;
+        }
+        catch {
+            // ignore malformed entry lines
+        }
+    }
+    return { header, entries, leafId };
+}
+export class JsonlSessionStorage {
+    filePath;
+    metadata;
+    entries;
+    byId;
+    labelsById;
+    currentLeafId;
+    constructor(filePath, header, entries, leafId) {
+        this.filePath = resolve(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(filePath) {
+        const resolvedPath = resolve(filePath);
+        const loaded = await loadJsonlStorage(resolvedPath);
+        return new JsonlSessionStorage(resolvedPath, loaded.header, loaded.entries, loaded.leafId);
+    }
+    static async create(filePath, options) {
+        const resolvedPath = resolve(filePath);
+        const header = {
+            type: "session",
+            version: 3,
+            id: options.sessionId,
+            timestamp: new Date().toISOString(),
+            cwd: options.cwd,
+            parentSession: options.parentSessionPath,
+        };
+        await mkdir(dirname(resolvedPath), { recursive: true });
+        await writeFile(resolvedPath, `${JSON.stringify(header)}\n`);
+        return new JsonlSessionStorage(resolvedPath, header, [], null);
+    }
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getLeafId() {
+        return this.currentLeafId;
+    }
+    async setLeafId(leafId) {
+        if (leafId !== null && !this.byId.has(leafId)) {
+            throw new Error(`Entry ${leafId} not found`);
+        }
+        this.currentLeafId = leafId;
+    }
+    async createEntryId() {
+        return generateEntryId(this.byId);
+    }
+    async appendEntry(entry) {
+        await appendFile(this.filePath, `${JSON.stringify(entry)}\n`);
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        updateLabelCache(this.labelsById, entry);
+        this.currentLeafId = entry.id;
+    }
+    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);
+        while (current) {
+            path.unshift(current);
+            current = current.parentId ? this.byId.get(current.parentId) : undefined;
+        }
+        return path;
+    }
+    async getEntries() {
+        return [...this.entries];
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/storage/memory.js

@@ -0,0 +1,90 @@
+import { randomUUID } from "node:crypto";
+import { v7 as uuidv7 } from "uuid";
+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 = randomUUID().slice(0, 8);
+        if (!byId.has(id))
+            return id;
+    }
+    return randomUUID();
+}
+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 = options?.leafId ?? this.entries[this.entries.length - 1]?.id ?? null;
+        if (this.leafId !== null && !this.byId.has(this.leafId)) {
+            throw new Error(`Entry ${this.leafId} not found`);
+        }
+        this.metadata = options?.metadata ?? { id: uuidv7(), createdAt: new Date().toISOString() };
+    }
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getLeafId() {
+        return this.leafId;
+    }
+    async setLeafId(leafId) {
+        if (leafId !== null && !this.byId.has(leafId)) {
+            throw new Error(`Entry ${leafId} not found`);
+        }
+        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 = entry.id;
+    }
+    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);
+        while (current) {
+            path.unshift(current);
+            current = current.parentId ? this.byId.get(current.parentId) : undefined;
+        }
+        return path;
+    }
+    async getEntries() {
+        return [...this.entries];
+    }
+}
+//# sourceMappingURL=memory.js.map