@streichsbaer/pi-mesh 0.1.0

package/dist/model-selection.js

@@ -0,0 +1,171 @@
+import { THINKING_LEVELS } from "./types.js";
+export function isThinkingLevel(value) {
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
+export function hasModelSelection(selection) {
+    return Boolean(selection?.provider || selection?.model || selection?.thinkingLevel);
+}
+export function formatModelRef(model) {
+    return `${model.provider}/${model.id}`;
+}
+export function modelMatches(model, other) {
+    return model?.provider === other.provider && model.id === other.id;
+}
+export function splitModelThinking(modelRef) {
+    const colonIndex = modelRef.lastIndexOf(":");
+    if (colonIndex > 0) {
+        const suffix = modelRef.slice(colonIndex + 1);
+        if (isThinkingLevel(suffix))
+            return { modelRef: modelRef.slice(0, colonIndex), thinkingLevel: suffix };
+    }
+    return { modelRef };
+}
+export function modelRefHasThinkingSuffix(modelRef) {
+    return Boolean(modelRef && splitModelThinking(modelRef).thinkingLevel);
+}
+export function mergeModelSelection(base, override) {
+    if (!base)
+        return override;
+    if (!override)
+        return base;
+    if (!override.model && !override.provider)
+        return { ...base, thinkingLevel: override.thinkingLevel ?? base.thinkingLevel };
+    return {
+        provider: override.provider,
+        model: override.model,
+        thinkingLevel: override.thinkingLevel ?? (modelRefHasThinkingSuffix(override.model) ? undefined : base.thinkingLevel),
+    };
+}
+function selectUniqueModel(matches, requested) {
+    if (matches.length === 0)
+        return undefined;
+    if (matches.length === 1)
+        return matches[0];
+    const examples = matches.slice(0, 8).map(formatModelRef).join(", ");
+    const suffix = matches.length > 8 ? `, ... ${matches.length - 8} more` : "";
+    throw new Error(`Model ${JSON.stringify(requested)} is ambiguous. Use provider/model. Matches: ${examples}${suffix}`);
+}
+export function resolveModelRef(modelRegistry, requested, providerInput) {
+    const models = modelRegistry.getAll();
+    if (models.length === 0)
+        throw new Error("No models available. Check your Pi installation or models.json.");
+    const providerMap = new Map();
+    for (const model of models)
+        providerMap.set(model.provider.toLowerCase(), model.provider);
+    let provider = providerInput ? providerMap.get(providerInput.toLowerCase()) : undefined;
+    if (providerInput && !provider) {
+        throw new Error(`Unknown provider ${JSON.stringify(providerInput)}. Use \`pi --list-models\` to see available providers/models.`);
+    }
+    let pattern = requested;
+    if (provider && requested.toLowerCase().startsWith(`${provider.toLowerCase()}/`)) {
+        pattern = requested.slice(provider.length + 1);
+    }
+    if (!provider) {
+        const slashIndex = requested.indexOf("/");
+        if (slashIndex !== -1) {
+            const maybeProvider = requested.slice(0, slashIndex);
+            const canonical = providerMap.get(maybeProvider.toLowerCase());
+            if (canonical) {
+                provider = canonical;
+                pattern = requested.slice(slashIndex + 1);
+            }
+        }
+    }
+    const candidates = provider ? models.filter((model) => model.provider === provider) : models;
+    const normalized = pattern.toLowerCase();
+    const exact = selectUniqueModel(candidates.filter((model) => {
+        const id = model.id.toLowerCase();
+        const canonical = formatModelRef(model).toLowerCase();
+        return id === normalized || canonical === requested.toLowerCase();
+    }), requested);
+    if (exact)
+        return exact;
+    const fuzzy = selectUniqueModel(candidates.filter((model) => model.id.toLowerCase().includes(normalized) || model.name?.toLowerCase().includes(normalized)), requested);
+    if (fuzzy)
+        return fuzzy;
+    const display = provider ? `${provider}/${pattern}` : requested;
+    throw new Error(`Model ${JSON.stringify(display)} not found. Use \`pi --list-models\` to see available models.`);
+}
+export function resolveRequestedModelSelection(modelRegistry, selection) {
+    const provider = selection?.provider?.trim();
+    const modelInput = selection?.model?.trim();
+    if (provider && !modelInput)
+        throw new Error("--provider requires --model.");
+    let model;
+    const requestedThinking = selection?.thinkingLevel;
+    if (requestedThinking !== undefined && !isThinkingLevel(String(requestedThinking))) {
+        throw new Error(`Invalid --thinking ${JSON.stringify(requestedThinking)}. Expected: ${THINKING_LEVELS.join(", ")}.`);
+    }
+    let thinkingLevel = requestedThinking;
+    let explicitThinking = thinkingLevel !== undefined;
+    if (modelInput) {
+        try {
+            model = resolveModelRef(modelRegistry, modelInput, provider);
+        }
+        catch (error) {
+            const split = splitModelThinking(modelInput);
+            if (split.thinkingLevel === undefined)
+                throw error;
+            const modelRef = split.modelRef.trim();
+            if (!modelRef)
+                throw new Error("--model requires a non-empty value.");
+            model = resolveModelRef(modelRegistry, modelRef, provider);
+            thinkingLevel = thinkingLevel ?? split.thinkingLevel;
+            explicitThinking = true;
+        }
+        if (!modelRegistry.hasConfiguredAuth(model)) {
+            throw new Error(`No API key/auth configured for ${formatModelRef(model)}.`);
+        }
+    }
+    return {
+        model,
+        thinkingLevel,
+        explicitModel: modelInput !== undefined,
+        explicitThinking,
+    };
+}
+export function getSessionContextSnapshot(sessionManager) {
+    const context = sessionManager.buildSessionContext();
+    return {
+        messages: context.messages,
+        model: context.model,
+        thinkingLevel: context.thinkingLevel,
+        hasThinkingEntry: sessionManager.getBranch().some((entry) => entry.type === "thinking_level_change"),
+    };
+}
+export function restoreModelFromSession(modelRegistry, snapshot) {
+    if (!snapshot.model)
+        return undefined;
+    const model = modelRegistry.find(snapshot.model.provider, snapshot.model.modelId);
+    return model && modelRegistry.hasConfiguredAuth(model) ? model : undefined;
+}
+export function resolveSessionModelSelection(modelRegistry, snapshot, selection) {
+    const resolved = resolveRequestedModelSelection(modelRegistry, selection);
+    if (!resolved.model && !resolved.explicitModel)
+        resolved.model = restoreModelFromSession(modelRegistry, snapshot);
+    if (!resolved.thinkingLevel && !resolved.explicitThinking && snapshot.hasThinkingEntry && isThinkingLevel(snapshot.thinkingLevel)) {
+        resolved.thinkingLevel = snapshot.thinkingLevel;
+    }
+    return resolved;
+}
+export function persistThinkingLevelIfNeeded(session, thinkingLevel) {
+    if (session.thinkingLevel !== thinkingLevel) {
+        session.setThinkingLevel(thinkingLevel);
+        return;
+    }
+    if (session.sessionManager.buildSessionContext().thinkingLevel !== thinkingLevel) {
+        session.sessionManager.appendThinkingLevelChange(thinkingLevel);
+    }
+}
+export async function persistExplicitSelectionIfNeeded(session, snapshot, resolved) {
+    const hadMessages = snapshot.messages.length > 0;
+    if (hadMessages && resolved.explicitModel && resolved.model) {
+        const saved = snapshot.model;
+        if (!saved || saved.provider !== resolved.model.provider || saved.modelId !== resolved.model.id) {
+            await session.setModel(resolved.model);
+        }
+    }
+    if (hadMessages && resolved.explicitThinking && resolved.thinkingLevel && snapshot.thinkingLevel !== resolved.thinkingLevel) {
+        persistThinkingLevelIfNeeded(session, resolved.thinkingLevel);
+    }
+}

package/dist/pi-runner.d.ts

@@ -0,0 +1,39 @@
+import type { DeliveryMode, ModelSelection } from "./types.js";
+export { sendToLiveSocket } from "./live-socket.js";
+interface RunHeadlessTurnOptions {
+    cwd: string;
+    sessionFile?: string;
+    message: string;
+    delivery?: DeliveryMode;
+    stream?: boolean;
+    modelSelection?: ModelSelection;
+}
+interface RunInteractiveOptions {
+    cwd: string;
+    sessionFile?: string;
+    name?: string;
+    initialMessage?: string;
+    socketPath?: string;
+    modelSelection?: ModelSelection;
+    onSessionFile?: (sessionFile: string | undefined, rawSessionId: string) => Promise<void> | void;
+    onMaterialized?: () => Promise<void> | void;
+    onStatus?: (status: "running" | "idle" | "busy" | "offline" | "error", error?: string) => Promise<void> | void;
+}
+interface CreatePersistentSessionOptions {
+    cwd: string;
+    name?: string;
+    modelSelection?: ModelSelection;
+}
+export declare function validateModelSelection(options: {
+    cwd: string;
+    modelSelection?: ModelSelection;
+}): Promise<ModelSelection | undefined>;
+export declare function createPersistentSession(options: CreatePersistentSessionOptions): Promise<{
+    sessionFile?: string;
+    rawSessionId: string;
+}>;
+export declare function runHeadlessTurn(options: RunHeadlessTurnOptions): Promise<{
+    sessionFile?: string;
+    rawSessionId: string;
+}>;
+export declare function runInteractive(options: RunInteractiveOptions): Promise<void>;

package/dist/pi-runner.js

@@ -0,0 +1,182 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, InteractiveMode, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { getSessionContextSnapshot, hasModelSelection, isThinkingLevel, modelMatches, persistExplicitSelectionIfNeeded, persistThinkingLevelIfNeeded, resolveRequestedModelSelection, resolveSessionModelSelection, } from "./model-selection.js";
+import { startSessionSocket } from "./live-socket.js";
+export { sendToLiveSocket } from "./live-socket.js";
+async function createAgentSessionWithModelSelection(options) {
+    const snapshot = getSessionContextSnapshot(options.sessionManager);
+    const resolved = resolveSessionModelSelection(options.services.modelRegistry, snapshot, options.modelSelection);
+    const thinkingLevelForCreate = snapshot.messages.length > 0 && resolved.explicitThinking && snapshot.hasThinkingEntry && isThinkingLevel(snapshot.thinkingLevel)
+        ? snapshot.thinkingLevel
+        : resolved.thinkingLevel;
+    const created = await createAgentSessionFromServices({
+        services: options.services,
+        sessionManager: options.sessionManager,
+        sessionStartEvent: options.sessionStartEvent,
+        model: resolved.model,
+        thinkingLevel: thinkingLevelForCreate,
+    });
+    await persistExplicitSelectionIfNeeded(created.session, snapshot, resolved);
+    return created;
+}
+async function applyModelSelectionToLiveSession(session, selection) {
+    if (!hasModelSelection(selection))
+        return;
+    const resolved = resolveRequestedModelSelection(session.modelRegistry, selection);
+    if (resolved.model && !modelMatches(session.model, resolved.model))
+        await session.setModel(resolved.model);
+    if (resolved.thinkingLevel)
+        persistThinkingLevelIfNeeded(session, resolved.thinkingLevel);
+}
+export async function validateModelSelection(options) {
+    if (!hasModelSelection(options.modelSelection))
+        return undefined;
+    const services = await createAgentSessionServices({ cwd: options.cwd });
+    const resolved = resolveRequestedModelSelection(services.modelRegistry, options.modelSelection);
+    return {
+        provider: resolved.model?.provider,
+        model: resolved.model?.id,
+        thinkingLevel: resolved.thinkingLevel,
+    };
+}
+async function deliverToSession(session, message, delivery = "auto") {
+    if (delivery === "auto") {
+        if (session.isStreaming)
+            await session.followUp(message);
+        else
+            await session.prompt(message);
+        return;
+    }
+    if (delivery === "steer") {
+        if (session.isStreaming)
+            await session.steer(message);
+        else
+            await session.prompt(message);
+        return;
+    }
+    if (delivery === "follow-up") {
+        if (session.isStreaming)
+            await session.followUp(message);
+        else
+            await session.prompt(message);
+        return;
+    }
+    if (delivery === "prompt") {
+        if (session.isStreaming) {
+            throw new Error("Target session is streaming; use --delivery steer, follow-up, or auto.");
+        }
+        await session.prompt(message);
+        return;
+    }
+    throw new Error(`Unsupported delivery mode: ${delivery}`);
+}
+export async function createPersistentSession(options) {
+    const sessionManager = SessionManager.create(options.cwd);
+    if (options.name)
+        sessionManager.appendSessionInfo(options.name);
+    const services = await createAgentSessionServices({ cwd: options.cwd });
+    const { session } = await createAgentSessionWithModelSelection({ services, sessionManager, modelSelection: options.modelSelection });
+    try {
+        return { sessionFile: session.sessionFile, rawSessionId: session.sessionId };
+    }
+    finally {
+        session.dispose();
+    }
+}
+async function fileExists(filePath) {
+    if (!filePath)
+        return false;
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runHeadlessTurn(options) {
+    const sessionManager = options.sessionFile && (await fileExists(options.sessionFile))
+        ? SessionManager.open(options.sessionFile)
+        : SessionManager.create(options.cwd);
+    const services = await createAgentSessionServices({ cwd: options.cwd });
+    const { session } = await createAgentSessionWithModelSelection({ services, sessionManager, modelSelection: options.modelSelection });
+    try {
+        if (options.stream) {
+            session.subscribe((event) => {
+                if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+                    process.stdout.write(event.assistantMessageEvent.delta);
+                }
+            });
+        }
+        await deliverToSession(session, options.message, options.delivery ?? "auto");
+        await session.agent.waitForIdle();
+        if (options.stream)
+            process.stdout.write("\n");
+        return { sessionFile: session.sessionFile, rawSessionId: session.sessionId };
+    }
+    finally {
+        session.dispose();
+    }
+}
+function createRuntimeFactory(modelSelection) {
+    return async ({ cwd, sessionManager, sessionStartEvent }) => {
+        const services = await createAgentSessionServices({ cwd });
+        return {
+            ...(await createAgentSessionWithModelSelection({ services, sessionManager, sessionStartEvent, modelSelection })),
+            services,
+            diagnostics: services.diagnostics,
+        };
+    };
+}
+export async function runInteractive(options) {
+    const sessionManager = options.sessionFile
+        ? SessionManager.open(options.sessionFile)
+        : SessionManager.create(options.cwd);
+    if (options.name)
+        sessionManager.appendSessionInfo(options.name);
+    const runtime = await createAgentSessionRuntime(createRuntimeFactory(options.modelSelection), {
+        cwd: options.cwd,
+        agentDir: getAgentDir(),
+        sessionManager,
+    });
+    let server;
+    let unsubscribeMaterialized;
+    try {
+        await options.onSessionFile?.(runtime.session.sessionFile, runtime.session.sessionId);
+        await options.onStatus?.("running");
+        unsubscribeMaterialized = runtime.session.subscribe((event) => {
+            if (event.type === "agent_end" && !event.willRetry)
+                void options.onMaterialized?.();
+        });
+        if (options.socketPath) {
+            server = await startSessionSocket({
+                socketPath: options.socketPath,
+                getSession: () => runtime.session,
+                applyModelSelection: applyModelSelectionToLiveSession,
+                deliverToSession,
+                onStatus: options.onStatus,
+            });
+        }
+        const mode = new InteractiveMode(runtime, {
+            migratedProviders: [],
+            modelFallbackMessage: undefined,
+            initialMessage: options.initialMessage,
+            initialImages: [],
+            initialMessages: [],
+        });
+        await mode.run();
+    }
+    finally {
+        unsubscribeMaterialized?.();
+        await options.onStatus?.("offline");
+        const activeServer = server;
+        if (activeServer)
+            await new Promise((resolve) => activeServer.close(() => resolve()));
+        if (options.socketPath) {
+            await fs.rm(options.socketPath, { force: true }).catch(() => undefined);
+            await fs.rmdir(path.dirname(options.socketPath)).catch(() => undefined);
+        }
+        await runtime.dispose();
+    }
+}

package/dist/pi-session-parser.d.ts

@@ -0,0 +1,57 @@
+import type { AgentMessageLike, ContentPartLike, SessionData, SessionSummary, ToolInvocation, TranscriptEntry, TranscriptEvent, Turn } from "./types.js";
+interface RegistryHint {
+    sessionId?: string;
+    sessionFile?: string;
+    sessionName?: string;
+    workflowId?: string;
+    providerId?: string;
+    laneId?: string;
+    [key: string]: unknown;
+}
+interface RegistryHints {
+    bySessionId: Map<string, RegistryHint & {
+        _recordPath: string;
+    }>;
+    bySessionFile: Map<string, RegistryHint & {
+        _recordPath: string;
+    }>;
+}
+export interface SessionSearchOptions {
+    query?: string;
+    limit?: number;
+    sessionRoot?: string;
+    registryRoots?: string[];
+}
+export interface TimeWindow {
+    since?: number | null;
+    until?: number | null;
+}
+export declare function contentText(part: ContentPartLike, options?: {
+    includeThinking?: boolean;
+}): string;
+export declare function messageText(message: AgentMessageLike | undefined, options?: {
+    includeThinking?: boolean;
+}): string;
+export declare function parseSessionSummary(filePath: string, hints?: RegistryHints): Promise<SessionSummary | null>;
+export declare function matchesSessionSummary(item: SessionSummary, query?: string): boolean;
+export declare function searchSessions(options?: SessionSearchOptions): Promise<SessionSummary[]>;
+export declare function resolveSessionSpec(spec: string, options?: SessionSearchOptions): Promise<SessionSummary>;
+export declare function loadActiveBranch(sessionFile: string): Promise<{
+    header: {
+        id: string;
+        version?: number;
+        cwd?: string;
+        timestamp?: string;
+    };
+    entries: TranscriptEntry[];
+}>;
+export declare function normalizeEvents(entries: TranscriptEntry[]): TranscriptEvent[];
+export declare function summarizeArgs(toolName: string | undefined, args: Record<string, unknown> | undefined): string;
+export declare function buildToolInvocations(events: TranscriptEvent[]): ToolInvocation[];
+export declare function buildTurns(events: TranscriptEvent[]): Turn[];
+export declare function inWindow(timestampMs: number | null | undefined, window?: TimeWindow): boolean;
+export declare function tail<T>(items: T[], count: number): T[];
+export declare function loadSessionDataForSession(session: SessionSummary): Promise<SessionData>;
+export declare function loadSessionData(spec: string, options?: SessionSearchOptions): Promise<SessionData>;
+export declare function renderToolLine(item: ToolInvocation): string;
+export {};