@aexol/spectral 0.3.6 → 0.3.8

package/dist/memory/runtime.js

@@ -0,0 +1,62 @@
+import { DEFAULTS, loadConfig } from "./config.js";
+export class Runtime {
+    config = { ...DEFAULTS };
+    configLoaded = false;
+    observerInFlight = false;
+    observerPromise = null;
+    compactInFlight = false;
+    compactHookInFlight = false;
+    resolveFailureNotified = false;
+    ensureConfig(cwd) {
+        if (this.configLoaded)
+            return;
+        this.config = loadConfig(cwd);
+        this.configLoaded = true;
+    }
+    async resolveModel(ctx) {
+        let model = ctx.model;
+        if (this.config.compactionModel) {
+            const configured = ctx.modelRegistry.find(this.config.compactionModel.provider, this.config.compactionModel.id);
+            if (configured) {
+                model = configured;
+            }
+            else if (ctx.hasUI && ctx.ui) {
+                ctx.ui.notify(`Observational memory: configured model ${this.config.compactionModel.provider}/${this.config.compactionModel.id} not found, using session model`, "warning");
+            }
+        }
+        if (!model)
+            return { ok: false, reason: "no model available (session has no model and no compactionModel configured)" };
+        const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+        if (!auth.ok || !auth.apiKey) {
+            const provider = model.provider ?? "unknown";
+            return { ok: false, reason: `no API key for provider "${provider}"` };
+        }
+        return { ok: true, model, apiKey: auth.apiKey, headers: auth.headers };
+    }
+    launchObserverTask(ctx, label, work) {
+        this.observerInFlight = true;
+        // Capture ctx properties synchronously — after `await work()` the extension ctx
+        // may be stale (e.g. after ctx.newSession/fork/switchSession/reload), and accessing
+        // ctx.hasUI or ctx.ui on a stale proxy throws.
+        const hasUI = ctx.hasUI;
+        const ui = ctx.ui;
+        let promise;
+        promise = (async () => {
+            try {
+                await work();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                if (hasUI && ui)
+                    ui.notify(`Observational memory: ${label} failed: ${msg}`, "warning");
+            }
+            finally {
+                this.observerInFlight = false;
+                if (this.observerPromise === promise)
+                    this.observerPromise = null;
+            }
+        })();
+        this.observerPromise = promise;
+        return promise;
+    }
+}

package/dist/memory/serialize.js

@@ -0,0 +1,199 @@
+function pad(n) {
+    return n.toString().padStart(2, "0");
+}
+function fmtLocal(d) {
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function formatTimestamp(v) {
+    if (v === undefined)
+        return "????-??-?? ??:??";
+    const d = new Date(v);
+    return Number.isNaN(d.getTime()) ? "????-??-?? ??:??" : fmtLocal(d);
+}
+function formatRecallTimestamp(...values) {
+    for (const v of values) {
+        if (v === undefined)
+            continue;
+        const d = new Date(v);
+        if (!Number.isNaN(d.getTime()))
+            return fmtLocal(d);
+    }
+    return "Unknown time";
+}
+function textAndPlaceholders(content, options = {}) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "[non-text content omitted]";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            parts.push("[non-text content omitted]");
+            continue;
+        }
+        if (block.type === "text" && typeof block.text === "string") {
+            parts.push(block.text);
+            continue;
+        }
+        if (block.type === "thinking") {
+            if (options.omitRedactedThinking && block.redacted === true)
+                continue;
+            if (options.includeThinking && typeof block.thinking === "string") {
+                parts.push(`[thinking: ${block.thinking}]`);
+                continue;
+            }
+            parts.push("[non-text content omitted]");
+            continue;
+        }
+        if (block.type === "toolCall" && typeof block.name === "string") {
+            parts.push(`[${block.name}(${JSON.stringify(block.arguments ?? {})})]`);
+            continue;
+        }
+        parts.push("[non-text content omitted]");
+    }
+    return parts.join("\n");
+}
+function textOnly(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("\n");
+}
+export function serializeConversation(messages) {
+    return messages
+        .map((msg) => {
+        const time = formatTimestamp(msg.timestamp);
+        if (msg.role === "user") {
+            const text = textOnly(msg.content);
+            return `[User @ ${time}]: ${text}`;
+        }
+        if (msg.role === "assistant") {
+            const body = textAndPlaceholders(msg.content, {
+                includeThinking: true,
+                omitRedactedThinking: true,
+            })
+                .split("\n")
+                .filter(Boolean)
+                .join("\n");
+            if (!body)
+                return null;
+            return `[Assistant @ ${time}]: ${body}`;
+        }
+        const text = textOnly(msg.content);
+        return `[Tool result for ${msg.toolName} @ ${time}]: ${text}`;
+    })
+        .filter((line) => line !== null)
+        .join("\n\n");
+}
+export function nowTimestamp() {
+    return fmtLocal(new Date());
+}
+export const MAX_RECORD_CONTENT_CHARS = 10_000;
+export function truncateRecordContent(content) {
+    if (content.length <= MAX_RECORD_CONTENT_CHARS)
+        return content;
+    const head = content.slice(0, MAX_RECORD_CONTENT_CHARS);
+    const dropped = content.length - MAX_RECORD_CONTENT_CHARS;
+    return `${head} … [truncated ${dropped} chars]`;
+}
+function renderCustomMessage(entry, options) {
+    const time = options.recallFormat ? formatRecallTimestamp(entry.timestamp) : formatTimestamp(entry.timestamp);
+    const text = options.recallFormat
+        ? textAndPlaceholders(entry.content)
+        : typeof entry.content === "string"
+            ? entry.content
+            : Array.isArray(entry.content)
+                ? entry.content
+                    .filter((b) => b?.type === "text" && typeof b.text === "string")
+                    .map((b) => b.text)
+                    .join("\n")
+                : "";
+    if (options.recallFormat) {
+        const origin = entry.customType ? `Custom message (${entry.customType})` : "Custom message";
+        return `[${origin} @ ${time}]: ${text}`;
+    }
+    const tag = entry.customType ? `Custom (${entry.customType})` : "Custom";
+    return `[${tag} @ ${time}]: ${text}`;
+}
+export function serializeBranchEntries(entries) {
+    const blocks = [];
+    for (const entry of entries) {
+        if (entry.type === "message" && entry.message) {
+            const part = serializeConversation([entry.message]);
+            if (part)
+                blocks.push(part);
+            continue;
+        }
+        if (entry.type === "custom_message") {
+            blocks.push(renderCustomMessage(entry, { recallFormat: false }));
+            continue;
+        }
+        if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+            const time = formatTimestamp(entry.timestamp);
+            blocks.push(`[Branch summary @ ${time}]: ${entry.summary}`);
+        }
+    }
+    return blocks.join("\n\n");
+}
+function isSourceRenderableEntry(entry) {
+    return entry.type === "message" || entry.type === "custom_message" || entry.type === "branch_summary";
+}
+export function serializeSourceAddressedBranchEntries(entries) {
+    const blocks = [];
+    const sourceEntryIds = [];
+    for (const entry of entries) {
+        if (!entry.id || !isSourceRenderableEntry(entry))
+            continue;
+        const rendered = serializeBranchEntries([entry]);
+        if (!rendered.trim())
+            continue;
+        sourceEntryIds.push(entry.id);
+        blocks.push(`[Source entry id: ${entry.id}]\n${rendered}`);
+    }
+    return { text: blocks.join("\n\n"), sourceEntryIds };
+}
+function renderRecallMessage(entry) {
+    if (!entry.message || typeof entry.message !== "object")
+        return null;
+    const msg = entry.message;
+    const time = formatRecallTimestamp(msg.timestamp, entry.timestamp);
+    if (msg.role === "user") {
+        return `[User @ ${time}]: ${textAndPlaceholders(msg.content)}`;
+    }
+    if (msg.role === "assistant") {
+        const body = textAndPlaceholders(msg.content, {
+            includeThinking: true,
+            omitRedactedThinking: true,
+        })
+            .split("\n")
+            .filter(Boolean)
+            .join("\n");
+        if (!body)
+            return null;
+        return `[Assistant @ ${time}]: ${body}`;
+    }
+    return `[Tool result: ${msg.toolName} @ ${time}]: ${textAndPlaceholders(msg.content)}`;
+}
+export function renderRecallSourceEntry(entry) {
+    if (entry.type === "message")
+        return renderRecallMessage(entry);
+    if (entry.type === "custom_message")
+        return renderCustomMessage(entry, { recallFormat: true });
+    if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+        const time = formatRecallTimestamp(entry.timestamp);
+        return `[Branch summary @ ${time}]: ${entry.summary}`;
+    }
+    return null;
+}
+export function renderRecallSourceEntries(entries) {
+    return entries
+        .map(renderRecallSourceEntry)
+        .filter((block) => block !== null && block.trim().length > 0)
+        .join("\n\n");
+}

package/dist/memory/tokens.js

@@ -0,0 +1,26 @@
+import { estimateTokens as estimateMessageTokens } from "@mariozechner/pi-coding-agent";
+export function estimateStringTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export function estimateEntryTokens(entry) {
+    if (entry.type === "message" && entry.message) {
+        return estimateMessageTokens(entry.message);
+    }
+    if (entry.type === "custom_message" && entry.content) {
+        const content = entry.content;
+        if (typeof content === "string")
+            return estimateStringTokens(content);
+        if (Array.isArray(content)) {
+            let total = 0;
+            for (const block of content) {
+                if (block.type === "text" && block.text)
+                    total += estimateStringTokens(block.text);
+            }
+            return total;
+        }
+    }
+    if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+        return estimateStringTokens(entry.summary);
+    }
+    return 0;
+}