codechecker

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MemoryStore = void 0;
exports.readRecentMemorySummary = readRecentMemorySummary;
const crypto_1 = require("crypto");
const fs_1 = require("fs");
const promises_1 = __importDefault(require("fs/promises"));
const path_1 = __importDefault(require("path"));
class MemoryStore {
    root;
    folder;
    file;
    constructor(root) {
        this.root = root;
        this.folder = path_1.default.join(root, ".forge-memory");
        this.file = path_1.default.join(this.folder, "memory.jsonl");
    }
    async ensureReady() {
        await promises_1.default.mkdir(this.folder, { recursive: true });
    }
    async add(kind, content, meta = {}) {
        await this.ensureReady();
        const record = {
            id: (0, crypto_1.randomUUID)(),
            timestamp: new Date().toISOString(),
            kind,
            content,
            meta,
        };
        await promises_1.default.appendFile(this.file, JSON.stringify(record) + "\n", "utf8");
        return record;
    }
    async list(limit = 100) {
        if (!(0, fs_1.existsSync)(this.file)) {
            return [];
        }
        const raw = await promises_1.default.readFile(this.file, "utf8");
        return raw
            .split(/\r?\n/)
            .filter(Boolean)
            .map((line) => JSON.parse(line))
            .slice(-limit)
            .reverse();
    }
    async search(query, limit = 8) {
        const items = await this.list(1000);
        if (!query.trim()) {
            return items.slice(0, limit);
        }
        const terms = query
            .toLowerCase()
            .split(/\s+/)
            .filter(Boolean);
        const scored = items
            .map((record) => {
            const blob = JSON.stringify(record).toLowerCase();
            let score = 0;
            for (const term of terms) {
                if (blob.includes(term))
                    score += 1;
            }
            return { record, score };
        })
            .filter((entry) => entry.score > 0)
            .sort((a, b) => {
            if (b.score !== a.score)
                return b.score - a.score;
            return b.record.timestamp.localeCompare(a.record.timestamp);
        });
        return scored.slice(0, limit).map((entry) => entry.record);
    }
    async summary(limit = 8) {
        const items = await this.list(limit);
        if (!items.length) {
            return "";
        }
        return items
            .map((record, index) => {
            const meta = record.meta && Object.keys(record.meta).length > 0
                ? ` | meta=${JSON.stringify(record.meta)}`
                : "";
            return `${index + 1}. [${record.kind}] ${record.content}${meta}`;
        })
            .join("\n");
    }
}
exports.MemoryStore = MemoryStore;
async function readRecentMemorySummary(root, query) {
    const memory = new MemoryStore(root);
    const items = await memory.search(query, 8);
    if (!items.length) {
        return "";
    }
    return items
        .map((record, index) => `${index + 1}. [${record.kind}] ${record.content}`)
        .join("\n");
}