qlogicagent 2.13.5 → 2.13.6

package/dist/skills/memory/memdir.d.ts

@@ -1,93 +0,0 @@
-/** Max bytes (UTF-8) for INDEX.md to inject into system prompt (CC uses 25KB, we use 12KB). */
-export declare const INDEX_MAX_CHARS = 12288;
-/** Max lines for INDEX.md injection. */
-export declare const INDEX_MAX_LINES = 200;
-/** Max chars for a single topic file. */
-export declare const TOPIC_FILE_MAX_CHARS = 8192;
-/** Root directory: <project>/.qlogicagent/memory/ */
-export declare function getMemdirPath(projectRoot: string): string;
-/** Full path to INDEX.md */
-export declare function getIndexPath(projectRoot: string): string;
-export interface MemdirFileInfo {
-    name: string;
-    /** Size in bytes */
-    size: number;
-    /** Last modified ISO timestamp */
-    modifiedAt: string;
-    /** First non-empty line (preview) */
-    preview?: string;
-}
-export interface MemdirResult {
-    ok: boolean;
-    message: string;
-    /** File path relative to memdir */
-    file?: string;
-    /** Current INDEX.md char usage */
-    indexUsage?: string;
-}
-export declare function isMemoryContentSafe(text: string): boolean;
-export declare class Memdir {
-    private readonly root;
-    private indexCache;
-    constructor(projectRoot: string);
-    /** Get the root directory path of this MEMDIR. */
-    getRootPath(): string;
-    /** Ensure memdir exists with a default INDEX.md if missing. */
-    ensureInitialized(): void;
-    /**
-     * Get INDEX.md content for system prompt injection.
-     * Truncated to INDEX_MAX_CHARS / INDEX_MAX_LINES.
-     */
-    getIndexForPrompt(): string;
-    /** Get raw INDEX.md content (untruncated). */
-    getIndexRaw(): string;
-    /** Get INDEX.md usage stats. */
-    getIndexUsage(): {
-        chars: number;
-        lines: number;
-        percent: number;
-    };
-    /** Append a line/entry to INDEX.md. */
-    addToIndex(content: string): Promise<MemdirResult>;
-    /**
-     * Auto-compact INDEX.md by removing oldest non-structural entries to make room.
-     * Returns the compacted content with the new entry appended, or null if impossible.
-     *
-     * Entry-aware: removes complete logical entries (a non-indented line plus its
-     * continuation lines that start with whitespace/'-') to avoid half-entries.
-     */
-    private autoCompactIndex;
-    /** Replace text in INDEX.md (str_replace semantics). */
-    replaceInIndex(oldText: string, newText: string): Promise<MemdirResult>;
-    /** Remove text from INDEX.md. */
-    removeFromIndex(oldText: string): Promise<MemdirResult>;
-    /** List all memory files (excluding INDEX.md). */
-    listFiles(): Promise<MemdirFileInfo[]>;
-    /** Create a new topic file. Fails if it already exists. */
-    createFile(name: string, content: string): Promise<MemdirResult>;
-    /** Write/overwrite a topic file. Auto-splits if content > 8KB. */
-    writeFile(name: string, content: string): Promise<MemdirResult>;
-    /**
-     * Auto-split: write oversized content into numbered part files.
-     * e.g. "lesson-docker.md" → "lesson-docker-1.md", "lesson-docker-2.md"
-     */
-    private writeFileSplit;
-    /** Read a topic file. */
-    readFile(name: string): Promise<{
-        ok: boolean;
-        content?: string;
-        message: string;
-    }>;
-    /** Delete a topic file. INDEX.md cannot be deleted. */
-    deleteFile(name: string): Promise<MemdirResult>;
-    /** Search all memory files for keyword matches. Returns matching snippets. */
-    searchLocal(query: string): Promise<Array<{
-        file: string;
-        snippet: string;
-        score: number;
-    }>>;
-    private writeIndex;
-    private ensureDir;
-    /** Append an entry to the file listing section of INDEX.md (idempotent). */
-    private appendIndexEntry;
-}

package/dist/skills/memory/memdir.js

@@ -1,530 +0,0 @@
-// ============================================================
-// Memdir — CC-aligned file-based memory system.
-//
-// Architecture (Claude Code MEMORY.md parity):
-//
-//   ~/.qlogicagent/memory/
-//   ├── INDEX.md         ← Always injected into system prompt (max 4KB)
-//   ├── user-profile.md  ← User preferences, expertise, style
-//   ├── project-foo.md   ← Project-scoped notes
-//   ├── lesson-*.md      ← Lessons learned
-//   └── task-*.md        ← Task-specific notes
-//
-// INDEX.md is the "always visible" memory (cap: 4096 chars / 200 lines).
-// Topic files are loaded on demand via the memory tool's read_file action.
-// Agent manages both via tool actions (add, replace, remove for INDEX.md;
-// create_file, write_file, read_file, delete_file for topic files).
-//
-// Reference: claude-code src/memdir/memdir.ts + src/utils/claudemd.ts
-// ============================================================
-import { readFile, readdir, unlink, stat, mkdir } from "node:fs/promises";
-import { existsSync, readFileSync, mkdirSync, writeFileSync as fsWriteFileSync } from "node:fs";
-import { join } from "node:path";
-import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
-import { atomicWriteFile } from "../../runtime/infra/disk-storage.js";
-// ── Constants ───────────────────────────────────────────────
-/** Max bytes (UTF-8) for INDEX.md to inject into system prompt (CC uses 25KB, we use 12KB). */
-export const INDEX_MAX_CHARS = 12288;
-/** Max lines for INDEX.md injection. */
-export const INDEX_MAX_LINES = 200;
-/** Max chars for a single topic file. */
-export const TOPIC_FILE_MAX_CHARS = 8192;
-/** Directory name under .qlogicagent/ */
-const MEMDIR_NAME = "memory";
-/** Index file name */
-const INDEX_FILE = "INDEX.md";
-// ── Path helpers ────────────────────────────────────────
-/** Root directory: <project>/.qlogicagent/memory/ */
-export function getMemdirPath(projectRoot) {
-    return join(getDefaultPathService().getProjectAgentDir(projectRoot), MEMDIR_NAME);
-}
-/** Full path to INDEX.md */
-export function getIndexPath(projectRoot) {
-    return join(getMemdirPath(projectRoot), INDEX_FILE);
-}
-// ── Content safety ──────────────────────────────────────────
-const BLOCKED_PATTERNS = [
-    /ignore\s+(previous|all|above|prior)\s+instructions/i,
-    /you\s+are\s+now\s+/i,
-    /do\s+not\s+tell\s+the\s+user/i,
-    /system\s+prompt\s+override/i,
-];
-export function isMemoryContentSafe(text) {
-    return !BLOCKED_PATTERNS.some((pattern) => pattern.test(text));
-}
-// ── Filename validation ─────────────────────────────────────
-const VALID_FILENAME = /^[a-z0-9][a-z0-9\-_.]*\.md$/i;
-function isValidFilename(name) {
-    if (!VALID_FILENAME.test(name))
-        return false;
-    if (name === INDEX_FILE)
-        return false; // INDEX.md is managed internally
-    if (name.includes("..") || name.includes("/") || name.includes("\\"))
-        return false;
-    return true;
-}
-function extractLabeledMarker(text) {
-    const match = text.trim().match(/^([A-Za-z][A-Za-z0-9_-]{2,})\s*:/);
-    return match?.[1] ?? null;
-}
-function removeIndexEntriesContaining(raw, needle) {
-    const lines = raw.split("\n");
-    const result = [];
-    let changed = false;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (isRemovableIndexEntry(line) && line.includes(needle)) {
-            changed = true;
-            while (i + 1 < lines.length && isContinuationLine(lines[i + 1])) {
-                i++;
-            }
-            continue;
-        }
-        result.push(line);
-    }
-    return changed ? result.join("\n") : null;
-}
-function isRemovableIndexEntry(line) {
-    const trimmed = line.trim();
-    return trimmed !== "" && !line.startsWith("#") && !line.startsWith("<!--") && !isContinuationLine(line);
-}
-function isContinuationLine(line) {
-    return line.startsWith("  ") || line.startsWith("\t");
-}
-// ── Memdir class ────────────────────────────────────────────
-export class Memdir {
-    root;
-    indexCache = null;
-    constructor(projectRoot) {
-        this.root = getMemdirPath(projectRoot);
-    }
-    /** Get the root directory path of this MEMDIR. */
-    getRootPath() {
-        return this.root;
-    }
-    // ── Initialization ──────────────────────────────────────
-    /** Ensure memdir exists with a default INDEX.md if missing. */
-    ensureInitialized() {
-        if (!existsSync(this.root)) {
-            mkdirSync(this.root, { recursive: true });
-        }
-        const indexPath = join(this.root, INDEX_FILE);
-        if (!existsSync(indexPath)) {
-            const defaultIndex = [
-                "# Memory Index",
-                "",
-                "<!-- Agent-managed memory. Lines here are always visible in system prompt.>",
-                "<!-- Use memory tool to add notes, or create topic files for longer content.>",
-                "",
-                "## User Profile",
-                "",
-                "## Notes",
-                "",
-            ].join("\n");
-            writeFileSync(indexPath, defaultIndex);
-        }
-    }
-    // ── INDEX.md — always-injected block ────────────────────
-    /**
-     * Get INDEX.md content for system prompt injection.
-     * Truncated to INDEX_MAX_CHARS / INDEX_MAX_LINES.
-     */
-    getIndexForPrompt() {
-        const indexPath = join(this.root, INDEX_FILE);
-        if (!existsSync(indexPath))
-            return "";
-        let content;
-        try {
-            content = readFileSync(indexPath, "utf-8");
-        }
-        catch {
-            return "";
-        }
-        // Cache for KV stability within a turn
-        this.indexCache = content;
-        // Truncate by lines
-        const lines = content.split("\n");
-        if (lines.length > INDEX_MAX_LINES) {
-            content = lines.slice(0, INDEX_MAX_LINES).join("\n")
-                + `\n\n<!-- INDEX.md truncated: ${lines.length} lines total, showing first ${INDEX_MAX_LINES}>`;
-        }
-        // Truncate by bytes (UTF-8)
-        if (Buffer.byteLength(content, "utf-8") > INDEX_MAX_CHARS) {
-            // Find safe truncation point at char boundary
-            const buf = Buffer.from(content, "utf-8");
-            content = buf.subarray(0, INDEX_MAX_CHARS).toString("utf-8")
-                + `\n\n<!-- INDEX.md truncated at ${INDEX_MAX_CHARS} bytes>`;
-        }
-        return content;
-    }
-    /** Get raw INDEX.md content (untruncated). */
-    getIndexRaw() {
-        const indexPath = join(this.root, INDEX_FILE);
-        if (!existsSync(indexPath))
-            return "";
-        try {
-            return readFileSync(indexPath, "utf-8");
-        }
-        catch {
-            return "";
-        }
-    }
-    /** Get INDEX.md usage stats. */
-    getIndexUsage() {
-        const raw = this.getIndexRaw();
-        const chars = Buffer.byteLength(raw, "utf-8");
-        const lines = raw.split("\n").length;
-        return { chars, lines, percent: Math.round((chars / INDEX_MAX_CHARS) * 100) };
-    }
-    // ── INDEX.md mutations ──────────────────────────────────
-    /** Append a line/entry to INDEX.md. */
-    async addToIndex(content) {
-        if (!content.trim()) {
-            return { ok: false, message: "Content cannot be empty." };
-        }
-        if (!isMemoryContentSafe(content)) {
-            return { ok: false, message: "Content rejected: potential injection detected." };
-        }
-        const raw = this.getIndexRaw();
-        const newContent = raw.endsWith("\n") ? raw + content.trim() + "\n" : raw + "\n" + content.trim() + "\n";
-        if (Buffer.byteLength(newContent, "utf-8") > INDEX_MAX_CHARS) {
-            // Auto-compact: remove oldest non-header entries to make room
-            const compacted = this.autoCompactIndex(raw, content.trim());
-            if (compacted) {
-                await this.writeIndex(compacted);
-                const usage = this.getIndexUsage();
-                return { ok: true, message: `Added to INDEX.md (auto-compacted old entries). [${usage.chars}/${INDEX_MAX_CHARS} chars, ${usage.percent}%]`, indexUsage: `${usage.chars}/${INDEX_MAX_CHARS}` };
-            }
-            const usage = this.getIndexUsage();
-            return { ok: false, message: `INDEX.md would exceed limit (${usage.chars}/${INDEX_MAX_CHARS} bytes) even after compaction. Create a topic file instead.` };
-        }
-        await this.writeIndex(newContent);
-        const usage = this.getIndexUsage();
-        return { ok: true, message: `Added to INDEX.md. [${usage.chars}/${INDEX_MAX_CHARS} chars, ${usage.percent}%]`, indexUsage: `${usage.chars}/${INDEX_MAX_CHARS}` };
-    }
-    /**
-     * Auto-compact INDEX.md by removing oldest non-structural entries to make room.
-     * Returns the compacted content with the new entry appended, or null if impossible.
-     *
-     * Entry-aware: removes complete logical entries (a non-indented line plus its
-     * continuation lines that start with whitespace/'-') to avoid half-entries.
-     */
-    autoCompactIndex(raw, newEntry) {
-        const lines = raw.split("\n");
-        const newEntryBytes = Buffer.byteLength(newEntry + "\n", "utf-8");
-        // Reserve space: target = INDEX_MAX_CHARS - newEntryBytes - 64 (safety margin)
-        const targetBytes = INDEX_MAX_CHARS - newEntryBytes - 64;
-        if (targetBytes < 256)
-            return null; // New entry too large
-        // Classify lines: structural (headers, HTML comments, empty) vs content
-        const isStructural = (line) => line.startsWith("#") || line.startsWith("<!--") || line.trim() === "";
-        // A continuation line belongs to the previous entry (indented, or sub-bullet)
-        const isContinuation = (line) => line.startsWith("  ") || line.startsWith("\t");
-        // Keep the first 4 lines (header block) always
-        const KEEP_HEADER_LINES = 4;
-        let result = [...lines];
-        // Remove complete entries (entry + continuations) from oldest until we fit
-        let attempts = 0;
-        while (Buffer.byteLength(result.join("\n"), "utf-8") > targetBytes && attempts < lines.length) {
-            // Find first removable entry start (non-structural, non-continuation, after header)
-            const idx = result.findIndex((line, i) => i >= KEEP_HEADER_LINES && !isStructural(line) && !isContinuation(line));
-            if (idx === -1)
-                break; // No more removable entries
-            // Remove this line and all following continuation lines
-            let removeCount = 1;
-            while (idx + removeCount < result.length && isContinuation(result[idx + removeCount])) {
-                removeCount++;
-            }
-            result.splice(idx, removeCount);
-            attempts++;
-        }
-        const compacted = result.join("\n");
-        const withNew = compacted.endsWith("\n")
-            ? compacted + newEntry + "\n"
-            : compacted + "\n" + newEntry + "\n";
-        if (Buffer.byteLength(withNew, "utf-8") <= INDEX_MAX_CHARS) {
-            return withNew;
-        }
-        return null;
-    }
-    /** Replace text in INDEX.md (str_replace semantics). */
-    async replaceInIndex(oldText, newText) {
-        if (!oldText.trim()) {
-            return { ok: false, message: "old_text cannot be empty." };
-        }
-        if (!newText.trim()) {
-            return { ok: false, message: "new_text cannot be empty. Use 'remove' to delete." };
-        }
-        if (!isMemoryContentSafe(newText)) {
-            return { ok: false, message: "Content rejected: potential injection detected." };
-        }
-        const raw = this.getIndexRaw();
-        const occurrences = raw.split(oldText).length - 1;
-        if (occurrences === 0) {
-            return { ok: false, message: `No match found for: "${oldText.slice(0, 80)}"` };
-        }
-        if (occurrences > 1) {
-            return { ok: false, message: `Multiple matches (${occurrences}) for: "${oldText.slice(0, 80)}". Be more specific.` };
-        }
-        const newRaw = raw.replace(oldText, newText);
-        if (Buffer.byteLength(newRaw, "utf-8") > INDEX_MAX_CHARS) {
-            return { ok: false, message: `Replacement would exceed INDEX.md limit (${Buffer.byteLength(newRaw, "utf-8")}/${INDEX_MAX_CHARS} bytes).` };
-        }
-        await this.writeIndex(newRaw);
-        const usage = this.getIndexUsage();
-        return { ok: true, message: `Replaced in INDEX.md. [${usage.chars}/${INDEX_MAX_CHARS} chars]`, indexUsage: `${usage.chars}/${INDEX_MAX_CHARS}` };
-    }
-    /** Remove text from INDEX.md. */
-    async removeFromIndex(oldText) {
-        if (!oldText.trim()) {
-            return { ok: false, message: "old_text cannot be empty." };
-        }
-        const raw = this.getIndexRaw();
-        const marker = extractLabeledMarker(oldText);
-        let newRaw = marker ? removeIndexEntriesContaining(raw, marker) : null;
-        if (newRaw === null) {
-            if (!raw.includes(oldText)) {
-                return { ok: false, message: `No match found for: "${oldText.slice(0, 80)}"` };
-            }
-            newRaw = raw.replace(oldText, "");
-        }
-        // Remove + collapse double newlines
-        newRaw = newRaw.replace(/\n{3,}/g, "\n\n");
-        await this.writeIndex(newRaw);
-        const usage = this.getIndexUsage();
-        return { ok: true, message: `Removed from INDEX.md. [${usage.chars}/${INDEX_MAX_CHARS} chars]`, indexUsage: `${usage.chars}/${INDEX_MAX_CHARS}` };
-    }
-    // ── Topic file operations ───────────────────────────────
-    /** List all memory files (excluding INDEX.md). */
-    async listFiles() {
-        if (!existsSync(this.root))
-            return [];
-        const entries = await readdir(this.root);
-        const files = [];
-        for (const entry of entries) {
-            if (entry === INDEX_FILE)
-                continue;
-            if (!entry.endsWith(".md"))
-                continue;
-            const fullPath = join(this.root, entry);
-            try {
-                const st = await stat(fullPath);
-                if (!st.isFile())
-                    continue;
-                // Read first non-empty line as preview
-                const raw = await readFile(fullPath, "utf-8");
-                const firstLine = raw.split("\n").find(l => l.trim() && !l.startsWith("#"))?.trim();
-                files.push({
-                    name: entry,
-                    size: st.size,
-                    modifiedAt: st.mtime.toISOString(),
-                    preview: firstLine?.slice(0, 100),
-                });
-            }
-            catch { /* skip unreadable files */ }
-        }
-        return files.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
-    }
-    /** Create a new topic file. Fails if it already exists. */
-    async createFile(name, content) {
-        if (!isValidFilename(name)) {
-            return { ok: false, message: `Invalid filename: "${name}". Use kebab-case .md files (e.g. "project-notes.md").` };
-        }
-        if (!isMemoryContentSafe(content)) {
-            return { ok: false, message: "Content rejected: potential injection detected." };
-        }
-        if (content.length > TOPIC_FILE_MAX_CHARS) {
-            return { ok: false, message: `Content too long (${content.length} chars, max ${TOPIC_FILE_MAX_CHARS}).` };
-        }
-        const fullPath = join(this.root, name);
-        if (existsSync(fullPath)) {
-            return { ok: false, message: `File already exists: "${name}". Use write_file to update.` };
-        }
-        await this.ensureDir();
-        await atomicWriteFile(fullPath, content);
-        // Auto-append entry to INDEX.md
-        const indexEntry = `- [${name}] — created ${new Date().toISOString().slice(0, 10)}`;
-        await this.appendIndexEntry(indexEntry);
-        return { ok: true, message: `Created "${name}" (${content.length} chars). Entry added to INDEX.md.`, file: name };
-    }
-    /** Write/overwrite a topic file. Auto-splits if content > 8KB. */
-    async writeFile(name, content) {
-        if (!isValidFilename(name)) {
-            return { ok: false, message: `Invalid filename: "${name}". Use kebab-case .md files.` };
-        }
-        if (!isMemoryContentSafe(content)) {
-            return { ok: false, message: "Content rejected: potential injection detected." };
-        }
-        // Auto-split: if content exceeds limit, split into numbered parts
-        if (content.length > TOPIC_FILE_MAX_CHARS) {
-            return this.writeFileSplit(name, content);
-        }
-        const fullPath = join(this.root, name);
-        const isNew = !existsSync(fullPath);
-        await this.ensureDir();
-        await atomicWriteFile(fullPath, content);
-        if (isNew) {
-            const indexEntry = `- [${name}] — created ${new Date().toISOString().slice(0, 10)}`;
-            await this.appendIndexEntry(indexEntry);
-        }
-        return { ok: true, message: `${isNew ? "Created" : "Updated"} "${name}" (${content.length} chars).`, file: name };
-    }
-    /**
-     * Auto-split: write oversized content into numbered part files.
-     * e.g. "lesson-docker.md" → "lesson-docker-1.md", "lesson-docker-2.md"
-     */
-    async writeFileSplit(name, content) {
-        const baseName = name.replace(/\.md$/, "");
-        const paragraphs = content.split(/\n{2,}/);
-        const parts = [];
-        let current = "";
-        for (const para of paragraphs) {
-            if (current.length + para.length + 2 > TOPIC_FILE_MAX_CHARS * 0.9 && current.length > 0) {
-                parts.push(current);
-                current = para;
-            }
-            else {
-                current = current ? current + "\n\n" + para : para;
-            }
-        }
-        if (current)
-            parts.push(current);
-        // Write each part
-        const writtenFiles = [];
-        for (let i = 0; i < parts.length; i++) {
-            const partName = `${baseName}-${i + 1}.md`;
-            const partPath = join(this.root, partName);
-            await this.ensureDir();
-            await atomicWriteFile(partPath, parts[i]);
-            writtenFiles.push(partName);
-        }
-        // Add index entries for all parts (if new)
-        const raw = this.getIndexRaw();
-        for (const partName of writtenFiles) {
-            if (!raw.includes(`[${partName}]`)) {
-                const entry = `- [${partName}] — auto-split ${new Date().toISOString().slice(0, 10)}`;
-                await this.appendIndexEntry(entry);
-            }
-        }
-        return {
-            ok: true,
-            message: `Auto-split "${name}" into ${parts.length} parts (${content.length} chars total): ${writtenFiles.join(", ")}`,
-            file: writtenFiles[0],
-        };
-    }
-    /** Read a topic file. */
-    async readFile(name) {
-        if (!isValidFilename(name) && name !== INDEX_FILE) {
-            return { ok: false, message: `Invalid filename: "${name}".` };
-        }
-        const fullPath = join(this.root, name);
-        try {
-            const content = await readFile(fullPath, "utf-8");
-            return { ok: true, content, message: `Read "${name}" (${content.length} chars).` };
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                return { ok: false, message: `File not found: "${name}".` };
-            }
-            return { ok: false, message: `Error reading "${name}": ${err.message}` };
-        }
-    }
-    /** Delete a topic file. INDEX.md cannot be deleted. */
-    async deleteFile(name) {
-        if (name === INDEX_FILE) {
-            return { ok: false, message: "Cannot delete INDEX.md. Use 'remove' to clear entries." };
-        }
-        if (!isValidFilename(name)) {
-            return { ok: false, message: `Invalid filename: "${name}".` };
-        }
-        const fullPath = join(this.root, name);
-        if (!existsSync(fullPath)) {
-            return { ok: false, message: `File not found: "${name}".` };
-        }
-        await unlink(fullPath);
-        // Remove index entry referencing this file
-        const raw = this.getIndexRaw();
-        const pattern = new RegExp(`^.*\\[${escapeRegex(name)}\\].*$\\n?`, "m");
-        if (pattern.test(raw)) {
-            const newRaw = raw.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-            await this.writeIndex(newRaw);
-        }
-        return { ok: true, message: `Deleted "${name}" and removed INDEX.md entry.`, file: name };
-    }
-    // ── Search (local keyword search across all files) ──────
-    /** Search all memory files for keyword matches. Returns matching snippets. */
-    async searchLocal(query) {
-        if (!existsSync(this.root))
-            return [];
-        const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 1);
-        if (queryWords.length === 0)
-            return [];
-        const entries = await readdir(this.root);
-        const results = [];
-        for (const entry of entries) {
-            if (!entry.endsWith(".md"))
-                continue;
-            const fullPath = join(this.root, entry);
-            try {
-                const content = await readFile(fullPath, "utf-8");
-                const contentLower = content.toLowerCase();
-                const matchCount = queryWords.filter(w => contentLower.includes(w)).length;
-                if (matchCount === 0)
-                    continue;
-                // Extract best matching line as snippet
-                const lines = content.split("\n");
-                let bestLine = "";
-                let bestScore = 0;
-                for (const line of lines) {
-                    const lineLower = line.toLowerCase();
-                    const lineScore = queryWords.filter(w => lineLower.includes(w)).length;
-                    if (lineScore > bestScore) {
-                        bestScore = lineScore;
-                        bestLine = line.trim();
-                    }
-                }
-                results.push({
-                    file: entry,
-                    snippet: bestLine.slice(0, 200),
-                    score: matchCount / queryWords.length,
-                });
-            }
-            catch { /* skip */ }
-        }
-        return results.sort((a, b) => b.score - a.score).slice(0, 10);
-    }
-    // ── Private helpers ─────────────────────────────────────
-    async writeIndex(content) {
-        await this.ensureDir();
-        await atomicWriteFile(join(this.root, INDEX_FILE), content);
-        this.indexCache = content;
-    }
-    async ensureDir() {
-        if (!existsSync(this.root)) {
-            await mkdir(this.root, { recursive: true });
-        }
-    }
-    /** Append an entry to the file listing section of INDEX.md (idempotent). */
-    async appendIndexEntry(entry) {
-        const raw = this.getIndexRaw();
-        // Don't add if already present
-        if (raw.includes(entry))
-            return;
-        // Append at end
-        const newContent = raw.endsWith("\n") ? raw + entry + "\n" : raw + "\n" + entry + "\n";
-        // Silently skip if would exceed limit
-        if (Buffer.byteLength(newContent, "utf-8") <= INDEX_MAX_CHARS) {
-            await this.writeIndex(newContent);
-        }
-    }
-}
-// ── Helpers ─────────────────────────────────────────────────
-function writeFileSync(path, content) {
-    const dir = join(path, "..");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    fsWriteFileSync(path, content, "utf-8");
-}
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/dist/skills/memory/memory-attachment-store.d.ts

@@ -1,62 +0,0 @@
-/**
- * MemoryAttachmentStore — persistent attachment storage for long-term memory.
- *
- * Files live beside the memory DB, with no expiry:
- *   ~/.qlogicagent/profiles/<owner>/memory/attachments/<id><ext>
- * The DB (`memory_attachments` table, via LocalMemoryStore) is the index;
- * this class owns the on-disk bytes + ties index rows to files.
- *
- * Lifecycle: an attachment is `adopt`ed at upload time (orphan, memory_id=''),
- * then `link`ed to a memory at commit; on memory delete the files+rows are
- * removed; long-orphaned uploads are purged.
- */
-import type { LocalMemoryStore, MemoryAttachmentRef, MemoryAttachmentRow } from "./local-store.js";
-export declare const MAX_ATTACHMENT_BYTES: number;
-export type AttachmentKind = "image" | "audio" | "video" | "doc" | "file";
-export declare function attachmentKindFromMime(mimeType: string, filename?: string): AttachmentKind;
-export interface AdoptedAttachment {
-    id: string;
-    kind: AttachmentKind;
-    filename: string;
-    mimeType: string;
-    size: number;
-    url: string;
-}
-export interface AdoptInput {
-    /** Raw bytes (preferred). */
-    data?: Buffer;
-    /** Or a URL the store fetches (e.g. the gateway's temp MediaStore url). */
-    sourceUrl?: string;
-    filename: string;
-    mimeType: string;
-    userId: string;
-}
-export declare class MemoryAttachmentStore {
-    private readonly store;
-    private readonly dir;
-    constructor(store: LocalMemoryStore, dir: string);
-    urlFor(id: string): string;
-    toRef(row: MemoryAttachmentRow): MemoryAttachmentRef;
-    /** Persist an uploaded file + create an orphan index row (memory_id=''). */
-    adopt(input: AdoptInput): Promise<AdoptedAttachment>;
-    /** Read an attachment's bytes + mime (for multimodal understanding). */
-    readBytes(id: string): Promise<{
-        bytes: Buffer;
-        mimeType: string;
-    } | null>;
-    /** Resolve an attachment to an absolute on-disk path (for serving). Guards traversal. */
-    locate(id: string): Promise<{
-        absPath: string;
-        mimeType: string;
-        filename: string;
-    } | null>;
-    link(memoryId: string, attachmentIds: string[], userId: string): number;
-    setExtractedText(id: string, text: string): void;
-    refsForMemory(memoryId: string): MemoryAttachmentRef[];
-    /** Map of memoryId → refs, for atlas windows. */
-    refsForMemories(memoryIds: string[]): Map<string, MemoryAttachmentRef[]>;
-    /** Remove all files + index rows for a deleted memory. */
-    removeByMemoryId(memoryId: string): Promise<void>;
-    /** Purge uploads that were never linked to a saved memory. */
-    purgeOrphans(olderThanMs?: number): Promise<void>;
-}