poe-code 3.0.184 → 3.0.185

package/packages/memory/dist/cache.cli.js

@@ -0,0 +1,24 @@
+import parseDuration from "parse-duration";
+import { clearCache } from "./cache.js";
+export async function runMemoryCacheStatus() {
+    console.log("cache status not implemented yet");
+}
+export async function runMemoryCacheClear(input) {
+    if (!input.yes) {
+        throw new Error("Refusing to clear cache without --yes.");
+    }
+    const olderThanMs = parseOlderThan(input.olderThan);
+    const result = await clearCache(input.root, olderThanMs === undefined ? {} : { olderThanMs });
+    console.log(`removed ${result.removed} cache ${result.removed === 1 ? "entry" : "entries"}`);
+    return result;
+}
+function parseOlderThan(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const duration = parseDuration(value);
+    if (duration === null || Number.isNaN(duration) || duration < 0) {
+        throw new Error(`Invalid duration for --older-than: "${value}".`);
+    }
+    return duration;
+}

package/packages/memory/dist/cache.d.ts

@@ -0,0 +1,14 @@
+import type { IngestCacheEntry, IngestCacheKey, MemoryRoot } from "./types.js";
+export declare function computeIngestKey(input: {
+    sourceBytes: Buffer;
+    indexMdBytes: Buffer;
+    promptTemplateVersion: string;
+    agentId: string;
+}): IngestCacheKey;
+export declare function readCacheEntry(root: MemoryRoot, key: IngestCacheKey): Promise<IngestCacheEntry | null>;
+export declare function writeCacheEntry(root: MemoryRoot, entry: IngestCacheEntry): Promise<void>;
+export declare function clearCache(root: MemoryRoot, opts?: {
+    olderThanMs?: number;
+}): Promise<{
+    removed: number;
+}>;

package/packages/memory/dist/cache.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { MEMORY_CACHE_DIR_RELPATH, MEMORY_INGEST_CACHE_DIR_RELPATH } from "./paths.js";
+export function computeIngestKey(input) {
+    const hash = createHash("sha256");
+    hash.update(input.sourceBytes);
+    hash.update("\0");
+    hash.update(input.indexMdBytes);
+    hash.update("\0");
+    hash.update(input.promptTemplateVersion);
+    hash.update("\0");
+    hash.update(input.agentId);
+    return hash.digest("hex");
+}
+export async function readCacheEntry(root, key) {
+    const cachePath = path.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
+    let raw;
+    try {
+        raw = await fs.readFile(cachePath, "utf8");
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return null;
+        }
+        throw error;
+    }
+    try {
+        return parseCacheEntry(JSON.parse(raw), key);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Ignoring ingest cache entry "${key}": ${message}`);
+        return null;
+    }
+}
+export async function writeCacheEntry(root, entry) {
+    await fs.mkdir(path.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+    await fs.writeFile(path.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`), `${JSON.stringify(entry)}\n`, "utf8");
+}
+export async function clearCache(root, opts = {}) {
+    const ingestDir = path.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+    const cacheDir = path.join(root, MEMORY_CACHE_DIR_RELPATH);
+    const fileNames = await readCacheFileNames(ingestDir);
+    if (fileNames.length === 0) {
+        if (opts.olderThanMs === undefined) {
+            await fs.rm(cacheDir, { recursive: true, force: true });
+        }
+        return { removed: 0 };
+    }
+    if (opts.olderThanMs === undefined) {
+        await fs.rm(cacheDir, { recursive: true, force: true });
+        return { removed: fileNames.length };
+    }
+    const cutoff = Date.now() - opts.olderThanMs;
+    let removed = 0;
+    for (const fileName of fileNames) {
+        const key = fileName.slice(0, -".json".length);
+        const entry = await readCacheEntry(root, key);
+        if (entry === null || Date.parse(entry.ingestedAt) > cutoff) {
+            continue;
+        }
+        await fs.rm(path.join(ingestDir, fileName), { force: true });
+        removed += 1;
+    }
+    await removeEmptyDirectory(ingestDir);
+    await removeEmptyDirectory(cacheDir);
+    return { removed };
+}
+function parseCacheEntry(value, key) {
+    const object = expectRecord(value);
+    return {
+        key: expectString(object.key, "key"),
+        ingestedAt: expectString(object.ingestedAt, "ingestedAt"),
+        sourceLabel: expectString(object.sourceLabel, "sourceLabel"),
+        diff: parseMemoryDiff(object.diff),
+        exitCode: expectNumber(object.exitCode, "exitCode"),
+        durationMs: expectNumber(object.durationMs, "durationMs"),
+        memoryTokens: expectNumber(object.memoryTokens, "memoryTokens"),
+        sourceTokens: expectNumber(object.sourceTokens, "sourceTokens"),
+        promptTemplateVersion: expectString(object.promptTemplateVersion, "promptTemplateVersion"),
+        agentId: expectString(object.agentId, "agentId")
+    };
+}
+function parseMemoryDiff(value) {
+    const object = expectRecord(value);
+    return {
+        created: expectStringArray(object.created, "diff.created"),
+        updated: expectStringArray(object.updated, "diff.updated"),
+        deleted: expectStringArray(object.deleted, "diff.deleted")
+    };
+}
+function expectRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Expected a JSON object.");
+    }
+    return value;
+}
+function expectString(value, field) {
+    if (typeof value !== "string") {
+        throw new Error(`Expected string at "${field}".`);
+    }
+    return value;
+}
+function expectNumber(value, field) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new Error(`Expected number at "${field}".`);
+    }
+    return value;
+}
+function expectStringArray(value, field) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new Error(`Expected string[] at "${field}".`);
+    }
+    return value;
+}
+async function readCacheFileNames(ingestDir) {
+    try {
+        return (await fs.readdir(ingestDir))
+            .filter((fileName) => path.posix.extname(fileName).toLowerCase() === ".json")
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return [];
+        }
+        throw error;
+    }
+}
+async function removeEmptyDirectory(directoryPath) {
+    try {
+        const remainingEntries = await fs.readdir(directoryPath);
+        if (remainingEntries.length === 0) {
+            await fs.rmdir(directoryPath);
+        }
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/packages/memory/dist/confidence.d.ts

@@ -0,0 +1,4 @@
+import type { ConfidenceTag, TaggedClaim } from "./types.js";
+export declare const TAG_RE: RegExp;
+export declare function parseClaims(body: string): TaggedClaim[];
+export declare function serializeTag(tag: ConfidenceTag): string;

package/packages/memory/dist/confidence.js

@@ -0,0 +1,201 @@
+import { parseSourceRef, serializeSourceRef } from "./frontmatter.js";
+export const TAG_RE = /^<!--\s*memory:(?<verb>extracted|inferred|ambiguous)(?<rest>[^>]*?)-->\s*$/;
+export function parseClaims(body) {
+    const lines = normalizeNewlines(body).split("\n");
+    const claims = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const tagLine = lines[index] ?? "";
+        const match = TAG_RE.exec(tagLine);
+        if (match?.groups?.verb === undefined) {
+            continue;
+        }
+        const claimLines = [];
+        for (let claimIndex = index + 1; claimIndex < lines.length; claimIndex += 1) {
+            const line = lines[claimIndex] ?? "";
+            if (line.trim().length === 0 || TAG_RE.test(line)) {
+                break;
+            }
+            claimLines.push(line);
+        }
+        if (claimLines.length === 0) {
+            throw new Error(`Confidence tag on line ${index + 1} is not followed by a claim paragraph.`);
+        }
+        claims.push({
+            tag: parseTag(match.groups.verb, match.groups.rest ?? ""),
+            body: claimLines.join("\n"),
+            lineNumber: index + 1
+        });
+    }
+    return claims;
+}
+export function serializeTag(tag) {
+    switch (tag.verb) {
+        case "extracted":
+            return serializeComment("extracted", {
+                source: serializeSourceRef(tag.source),
+                ...(tag.note === undefined ? {} : { note: tag.note })
+            });
+        case "inferred":
+            return serializeComment("inferred", {
+                confidence: serializeConfidence(tag.confidence),
+                ...(tag.source === undefined ? {} : { source: serializeSourceRef(tag.source) }),
+                ...(tag.note === undefined ? {} : { note: tag.note })
+            });
+        case "ambiguous": {
+            const reason = tag.reason.trim();
+            if (reason.length === 0) {
+                throw new Error('Ambiguous confidence tags require a non-empty "reason".');
+            }
+            return serializeComment("ambiguous", { reason });
+        }
+    }
+}
+function parseTag(verb, rest) {
+    const attrs = parseAttributes(rest);
+    switch (verb) {
+        case "extracted": {
+            const source = attrs.source;
+            if (source === undefined) {
+                throw new Error('Extracted confidence tags require "source".');
+            }
+            assertOnlyKeys(attrs, verb, ["source", "note"]);
+            return {
+                verb,
+                source: parseSourceRef(source),
+                ...(attrs.note === undefined ? {} : { note: attrs.note })
+            };
+        }
+        case "inferred": {
+            const confidence = attrs.confidence;
+            if (confidence === undefined) {
+                throw new Error('Inferred confidence tags require "confidence".');
+            }
+            assertOnlyKeys(attrs, verb, ["confidence", "source", "note"]);
+            return {
+                verb,
+                confidence: parseConfidence(confidence),
+                ...(attrs.source === undefined ? {} : { source: parseSourceRef(attrs.source) }),
+                ...(attrs.note === undefined ? {} : { note: attrs.note })
+            };
+        }
+        case "ambiguous": {
+            const reason = attrs.reason?.trim();
+            if (reason === undefined || reason.length === 0) {
+                throw new Error('Ambiguous confidence tags require a non-empty "reason".');
+            }
+            assertOnlyKeys(attrs, verb, ["reason"]);
+            return {
+                verb,
+                reason
+            };
+        }
+    }
+}
+function parseAttributes(rest) {
+    const attrs = {};
+    let index = 0;
+    while (index < rest.length) {
+        index = skipWhitespace(rest, index);
+        if (index >= rest.length) {
+            break;
+        }
+        const keyStart = index;
+        while (index < rest.length && isKeyCharacter(rest[index] ?? "")) {
+            index += 1;
+        }
+        if (keyStart === index) {
+            throw new Error(`Invalid confidence tag attribute near "${rest.slice(index).trim()}".`);
+        }
+        const key = rest.slice(keyStart, index);
+        if ((rest[index] ?? "") !== "=") {
+            throw new Error(`Invalid confidence tag attribute "${key}".`);
+        }
+        index += 1;
+        const { value, nextIndex } = readAttributeValue(rest, index);
+        if (attrs[key] !== undefined) {
+            throw new Error(`Duplicate confidence tag attribute "${key}".`);
+        }
+        attrs[key] = value;
+        index = nextIndex;
+    }
+    return attrs;
+}
+function readAttributeValue(input, index) {
+    if (index >= input.length) {
+        throw new Error("Missing confidence tag attribute value.");
+    }
+    if (input[index] === '"') {
+        const endQuote = findClosingQuote(input, index + 1);
+        return {
+            value: JSON.parse(input.slice(index, endQuote + 1)),
+            nextIndex: endQuote + 1
+        };
+    }
+    let nextIndex = index;
+    while (nextIndex < input.length && !isWhitespace(input[nextIndex] ?? "")) {
+        nextIndex += 1;
+    }
+    if (nextIndex === index) {
+        throw new Error("Missing confidence tag attribute value.");
+    }
+    return {
+        value: input.slice(index, nextIndex),
+        nextIndex
+    };
+}
+function findClosingQuote(input, start) {
+    let escaped = false;
+    for (let index = start; index < input.length; index += 1) {
+        const char = input[index] ?? "";
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            return index;
+        }
+    }
+    throw new Error("Unterminated quoted confidence tag attribute.");
+}
+function assertOnlyKeys(attrs, verb, allowedKeys) {
+    const disallowedKeys = Object.keys(attrs).filter((key) => !allowedKeys.includes(key));
+    if (disallowedKeys.length > 0) {
+        throw new Error(`${verb} confidence tags do not support: ${disallowedKeys.map((key) => `"${key}"`).join(", ")}.`);
+    }
+}
+function parseConfidence(rawConfidence) {
+    const confidence = Number(rawConfidence);
+    if (!Number.isFinite(confidence) || confidence <= 0 || confidence > 1) {
+        throw new Error(`Invalid confidence value "${rawConfidence}". Expected a number in (0, 1].`);
+    }
+    return confidence;
+}
+function serializeComment(verb, attrs) {
+    const parts = Object.entries(attrs).map(([key, value]) => `${key}=${serializeAttributeValue(key, value)}`);
+    return `<!-- memory:${verb}${parts.length === 0 ? "" : ` ${parts.join(" ")}`} -->`;
+}
+function serializeAttributeValue(key, value) {
+    return key === "source" || key === "confidence" ? value : JSON.stringify(value);
+}
+function serializeConfidence(confidence) {
+    return String(parseConfidence(String(confidence)));
+}
+function normalizeNewlines(value) {
+    return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function skipWhitespace(input, index) {
+    while (index < input.length && isWhitespace(input[index] ?? "")) {
+        index += 1;
+    }
+    return index;
+}
+function isKeyCharacter(char) {
+    return (char >= "a" && char <= "z") || (char >= "A" && char <= "Z");
+}
+function isWhitespace(char) {
+    return char === " " || char === "\t" || char === "\n" || char === "\r";
+}