@jim80net/memex-core 0.1.0

package/dist/project-registry.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectRegistry } from "./types.js";
+export declare function loadRegistry(registryPath: string): Promise<ProjectRegistry>;
+export declare function saveRegistry(registryPath: string, data: ProjectRegistry): Promise<void>;
+/**
+ * Register a project cwd as known. Mutates in place.
+ */
+export declare function registerProject(registry: ProjectRegistry, cwd: string): void;
+/**
+ * Get list of known project paths, sorted by most recently seen.
+ */
+export declare function getKnownProjects(registry: ProjectRegistry): string[];
+//# sourceMappingURL=project-registry.d.ts.map

package/dist/project-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-registry.d.ts","sourceRoot":"","sources":["../src/project-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAUjF;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAE5E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,EAAE,CAIpE"}

package/dist/project-registry.js

@@ -0,0 +1,38 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function loadRegistry(registryPath) {
+    const empty = { version: 1, projects: {} };
+    try {
+        const raw = await readFile(registryPath, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.version !== 1)
+            return empty;
+        return data;
+    }
+    catch {
+        return empty;
+    }
+}
+export async function saveRegistry(registryPath, data) {
+    const dir = dirname(registryPath);
+    await mkdir(dir, { recursive: true });
+    const tmpPath = `${registryPath}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    await rename(tmpPath, registryPath);
+}
+/**
+ * Register a project cwd as known. Mutates in place.
+ */
+export function registerProject(registry, cwd) {
+    registry.projects[cwd] = { lastSeen: new Date().toISOString() };
+}
+/**
+ * Get list of known project paths, sorted by most recently seen.
+ */
+export function getKnownProjects(registry) {
+    return Object.entries(registry.projects)
+        .sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+        .map(([path]) => path);
+}
+//# sourceMappingURL=project-registry.js.map

package/dist/project-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-registry.js","sourceRoot":"","sources":["../src/project-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,YAAoB;IACrD,MAAM,KAAK,GAAoB,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAC5D,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAoB,CAAC;QAChD,IAAI,IAAI,CAAC,OAAO,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,YAAoB,EAAE,IAAqB;IAC5E,MAAM,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,GAAG,YAAY,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC;IACxE,MAAM,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACjE,MAAM,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,QAAyB,EAAE,GAAW;IACpE,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;AAClE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAyB;IACxD,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;SACrC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;SAC5D,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC"}

package/dist/session.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Interface for tracking which rules have been shown per session.
+ * Implementations may use in-memory or file-based persistence.
+ */
+export interface SessionTracker {
+    hasRuleBeenShown(sessionId: string, location: string): boolean;
+    markRuleShown(sessionId: string, location: string): void;
+    clearSession(sessionId: string): void;
+    cleanup(maxAgeMs?: number): void;
+}
+/**
+ * In-memory session tracker. State resets on process restart.
+ */
+export declare class InMemorySessionTracker implements SessionTracker {
+    private shownRules;
+    hasRuleBeenShown(sessionId: string, location: string): boolean;
+    markRuleShown(sessionId: string, location: string): void;
+    clearSession(sessionId: string): void;
+    cleanup(maxAgeMs?: number): void;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/D,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACzD,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,UAAU,CAAsE;IAExF,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAM9D,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAUxD,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC,OAAO,CAAC,QAAQ,GAAE,MAAiB,GAAG,IAAI;CAQ3C"}

package/dist/session.js

@@ -0,0 +1,36 @@
+// ---------------------------------------------------------------------------
+// Session tracking for graduated disclosure
+// ---------------------------------------------------------------------------
+/**
+ * In-memory session tracker. State resets on process restart.
+ */
+export class InMemorySessionTracker {
+    shownRules = new Map();
+    hasRuleBeenShown(sessionId, location) {
+        const entry = this.shownRules.get(sessionId);
+        if (entry)
+            entry.lastAccess = Date.now();
+        return entry?.rules.has(location) ?? false;
+    }
+    markRuleShown(sessionId, location) {
+        let entry = this.shownRules.get(sessionId);
+        if (!entry) {
+            entry = { rules: new Set(), lastAccess: Date.now() };
+            this.shownRules.set(sessionId, entry);
+        }
+        entry.lastAccess = Date.now();
+        entry.rules.add(location);
+    }
+    clearSession(sessionId) {
+        this.shownRules.delete(sessionId);
+    }
+    cleanup(maxAgeMs = 3600_000) {
+        const cutoff = Date.now() - maxAgeMs;
+        for (const [key, entry] of this.shownRules) {
+            if (entry.lastAccess < cutoff) {
+                this.shownRules.delete(key);
+            }
+        }
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,4CAA4C;AAC5C,8EAA8E;AAa9E;;GAEG;AACH,MAAM,OAAO,sBAAsB;IACzB,UAAU,GAA4D,IAAI,GAAG,EAAE,CAAC;IAExF,gBAAgB,CAAC,SAAiB,EAAE,QAAgB;QAClD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,KAAK;YAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzC,OAAO,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC;IAC7C,CAAC;IAED,aAAa,CAAC,SAAiB,EAAE,QAAgB;QAC/C,IAAI,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,EAAE,KAAK,EAAE,IAAI,GAAG,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;QACD,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC9B,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED,YAAY,CAAC,SAAiB;QAC5B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,CAAC,WAAmB,QAAQ;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC;QACrC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAC3C,IAAI,KAAK,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC;gBAC9B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

package/dist/skill-index.d.ts

@@ -0,0 +1,52 @@
+import type { EmbeddingProvider } from "./embeddings.js";
+import type { MemexCoreConfig, ParsedFrontmatter, ScoringMode, SkillSearchResult, SkillType } from "./types.js";
+export declare function parseFrontmatter(content: string): {
+    meta: ParsedFrontmatter;
+    body: string;
+};
+/**
+ * Parse a memory markdown file into sections.
+ * Extracts ## sections and looks for `Triggers:` lines as queries.
+ */
+export declare function parseMemoryFile(content: string, _filePath: string): Array<{
+    name: string;
+    description: string;
+    queries: string[];
+    body: string;
+}>;
+export type ScanDirs = {
+    skillDirs: string[];
+    memoryDirs: string[];
+    ruleDirs: string[];
+};
+export declare class SkillIndex {
+    private config;
+    private provider;
+    private cachePath;
+    private skills;
+    private skillMtimes;
+    private cache;
+    private cacheLoaded;
+    private buildTime;
+    constructor(config: MemexCoreConfig, provider: EmbeddingProvider, cachePath: string);
+    get skillCount(): number;
+    needsRebuild(): boolean;
+    /**
+     * Build the index by scanning all skill, rule, and memory directories.
+     * Uses cache for unchanged files (mtime-gated).
+     */
+    build(scanDirs: ScanDirs): Promise<void>;
+    /**
+     * Search the index for skills matching the query.
+     * Supports both relative and absolute scoring modes.
+     */
+    search(query: string, topK: number, threshold: number, typeFilter?: SkillType[], scoringMode?: ScoringMode, maxDropoff?: number): Promise<SkillSearchResult[]>;
+    /**
+     * Read the body content of a skill file, stripping frontmatter.
+     */
+    readSkillContent(location: string): Promise<string>;
+    private parseSkillFileForEmbed;
+    private parseMemoryFileForEmbed;
+    private parseRuleFileForEmbed;
+}
+//# sourceMappingURL=skill-index.d.ts.map

package/dist/skill-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-index.d.ts","sourceRoot":"","sources":["../src/skill-index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,KAAK,EAGV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAC;AAQpB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAqD3F;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAmC/E;AA4ED,MAAM,MAAM,QAAQ,GAAG;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAiBF,qBAAa,UAAU;IAQnB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IATnB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAK;gBAGZ,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,EAAE,MAAM;IAG3B,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,YAAY,IAAI,OAAO;IAKvB;;;OAGG;IACG,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA0L9C;;;OAGG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,SAAS,EAAE,EACxB,WAAW,GAAE,WAAwB,EACrC,UAAU,GAAE,MAAa,GACxB,OAAO,CAAC,iBAAiB,EAAE,CAAC;IA+B/B;;OAEG;IACG,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBzD,OAAO,CAAC,sBAAsB;IAqB9B,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,qBAAqB;CA2B9B"}

package/dist/skill-index.js

@@ -0,0 +1,467 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { fromCachedSkill, loadCache, saveCache, toCachedSkill } from "./cache.js";
+import { cosineSimilarity } from "./embeddings.js";
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+const LIST_KEYS = new Set(["queries", "paths", "hooks", "keywords"]);
+export function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: content };
+    const frontmatter = match[1];
+    const body = match[2];
+    const meta = {};
+    let currentListKey = "";
+    const listAccumulators = {};
+    for (const line of frontmatter.split(/\r?\n/)) {
+        // Continue accumulating list items
+        if (currentListKey) {
+            const listItem = line.match(/^\s+-\s+(.*)/);
+            if (listItem) {
+                listAccumulators[currentListKey].push(listItem[1].replace(/^["']|["']$/g, "").trim());
+                continue;
+            }
+            currentListKey = "";
+        }
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const rawValue = line.slice(colonIdx + 1).trim();
+        const value = rawValue.replace(/^["']|["']$/g, "");
+        // Scalar keys
+        if (key === "name")
+            meta.name = value;
+        if (key === "description")
+            meta.description = value;
+        if (key === "type")
+            meta.type = value;
+        if (key === "one-liner")
+            meta.oneLiner = value;
+        // List keys — block-style (empty value + indented items) or inline value
+        if (LIST_KEYS.has(key)) {
+            if (rawValue === "") {
+                currentListKey = key;
+                listAccumulators[key] = [];
+            }
+            else {
+                // Inline value: treat as a single-element list
+                listAccumulators[key] = listAccumulators[key] || [];
+                listAccumulators[key].push(value);
+            }
+        }
+    }
+    if (listAccumulators.queries?.length)
+        meta.queries = listAccumulators.queries;
+    if (listAccumulators.paths?.length)
+        meta.paths = listAccumulators.paths;
+    if (listAccumulators.hooks?.length)
+        meta.hooks = listAccumulators.hooks;
+    if (listAccumulators.keywords?.length)
+        meta.keywords = listAccumulators.keywords;
+    return { meta, body };
+}
+// ---------------------------------------------------------------------------
+// Memory file parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse a memory markdown file into sections.
+ * Extracts ## sections and looks for `Triggers:` lines as queries.
+ */
+export function parseMemoryFile(content, _filePath) {
+    const results = [];
+    const sections = content.split(/^(?=##\s)/m);
+    for (const section of sections) {
+        const headingMatch = section.match(/^##\s+(.+)/);
+        if (!headingMatch)
+            continue;
+        const name = headingMatch[1].trim();
+        const bodyLines = [];
+        const queries = [];
+        for (const line of section.split(/\r?\n/).slice(1)) {
+            const triggerMatch = line.match(/^Triggers?:\s*(.+)/i);
+            if (triggerMatch) {
+                const raw = triggerMatch[1];
+                const parsed = raw
+                    .split(/,\s*/)
+                    .map((t) => t.replace(/^["']|["']$/g, "").trim())
+                    .filter((t) => t.length > 0);
+                queries.push(...parsed);
+            }
+            else {
+                bodyLines.push(line);
+            }
+        }
+        const body = bodyLines.join("\n").trim();
+        if (body.length > 0 || queries.length > 0) {
+            const description = body.split("\n")[0]?.trim() || name;
+            results.push({ name, description, queries, body });
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Directory scanning
+// ---------------------------------------------------------------------------
+async function scanSkillDirs(dirs) {
+    const skillFiles = [];
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const skillMd = join(dir, entry, "SKILL.md");
+            try {
+                await stat(skillMd);
+                skillFiles.push(skillMd);
+            }
+            catch {
+                // No SKILL.md in this subdirectory
+            }
+        }
+    }
+    return skillFiles;
+}
+async function scanMemoryDirs(dirs) {
+    const memoryFiles = [];
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".md"))
+                continue;
+            if (entry === "MEMORY.md")
+                continue;
+            memoryFiles.push(join(dir, entry));
+        }
+    }
+    return memoryFiles;
+}
+async function scanRuleDirs(dirs) {
+    const ruleFiles = [];
+    for (const dir of dirs) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".md"))
+                continue;
+            ruleFiles.push(join(dir, entry));
+        }
+    }
+    return ruleFiles;
+}
+export class SkillIndex {
+    config;
+    provider;
+    cachePath;
+    skills = [];
+    skillMtimes = new Map();
+    cache = null;
+    cacheLoaded = false;
+    buildTime = 0;
+    constructor(config, provider, cachePath) {
+        this.config = config;
+        this.provider = provider;
+        this.cachePath = cachePath;
+    }
+    get skillCount() {
+        return this.skills.length;
+    }
+    needsRebuild() {
+        if (this.buildTime === 0)
+            return true;
+        return Date.now() - this.buildTime >= this.config.cacheTimeMs;
+    }
+    /**
+     * Build the index by scanning all skill, rule, and memory directories.
+     * Uses cache for unchanged files (mtime-gated).
+     */
+    async build(scanDirs) {
+        // Load persistent cache on first build
+        if (!this.cacheLoaded) {
+            this.cache = await loadCache(this.cachePath, this.config.embeddingModel);
+            this.cacheLoaded = true;
+            // Hydrate from cache on cold start
+            if (this.skills.length === 0 && Object.keys(this.cache.skills).length > 0) {
+                for (const [location, cached] of Object.entries(this.cache.skills)) {
+                    this.skills.push(fromCachedSkill(location, cached));
+                    this.skillMtimes.set(location, cached.mtime);
+                }
+            }
+        }
+        // Scan all sources in parallel
+        const [skillFiles, memoryFiles, ruleFiles] = await Promise.all([
+            scanSkillDirs(scanDirs.skillDirs),
+            scanMemoryDirs(scanDirs.memoryDirs),
+            scanRuleDirs(scanDirs.ruleDirs),
+        ]);
+        const statPromises = [
+            ...skillFiles.map(async (f) => {
+                try {
+                    const s = await stat(f);
+                    return { location: f, mtime: s.mtimeMs, kind: "skill" };
+                }
+                catch {
+                    return null;
+                }
+            }),
+            ...memoryFiles.map(async (f) => {
+                try {
+                    const s = await stat(f);
+                    return { location: f, mtime: s.mtimeMs, kind: "memory" };
+                }
+                catch {
+                    return null;
+                }
+            }),
+            ...ruleFiles.map(async (f) => {
+                try {
+                    const s = await stat(f);
+                    return { location: f, mtime: s.mtimeMs, kind: "rule" };
+                }
+                catch {
+                    return null;
+                }
+            }),
+        ];
+        const statResults = (await Promise.all(statPromises)).filter((r) => r !== null);
+        const currentLocations = new Set(statResults.map((s) => s.location));
+        // Check for changes (fast path: skip if nothing changed)
+        const anyNew = statResults.some((s) => !this.skillMtimes.has(s.location));
+        const anyChanged = statResults.some((s) => this.skillMtimes.get(s.location) !== s.mtime);
+        const anyDeleted = [...this.skillMtimes.keys()].some((loc) => !currentLocations.has(loc));
+        if (this.buildTime > 0 && !anyNew && !anyChanged && !anyDeleted) {
+            this.buildTime = Date.now();
+            return;
+        }
+        // Find files that need (re)embedding
+        const toEmbed = [];
+        for (const info of statResults) {
+            if (info.kind === "memory") {
+                // Memory files may produce multiple sections — each keyed as "path#SectionName"
+                const cachedMtime = this.skillMtimes.get(info.location);
+                if (cachedMtime === info.mtime)
+                    continue;
+                // Remove old sections for this memory file
+                this.skills = this.skills.filter((s) => !s.location.startsWith(`${info.location}#`));
+                if (this.cache) {
+                    for (const key of Object.keys(this.cache.skills)) {
+                        if (key.startsWith(`${info.location}#`))
+                            delete this.cache.skills[key];
+                    }
+                }
+                try {
+                    const raw = await readFile(info.location, "utf-8");
+                    this.parseMemoryFileForEmbed(raw, info, toEmbed);
+                }
+                catch {
+                    // Skip unreadable
+                }
+                this.skillMtimes.set(info.location, info.mtime);
+                continue;
+            }
+            // Skills and rules
+            const cached = this.cache?.skills[info.location];
+            if (cached && cached.mtime === info.mtime) {
+                // Use cached embeddings — no re-embed
+                const existing = this.skills.findIndex((s) => s.location === info.location);
+                const skill = fromCachedSkill(info.location, cached);
+                if (existing >= 0)
+                    this.skills[existing] = skill;
+                else if (!this.skills.some((s) => s.location === info.location))
+                    this.skills.push(skill);
+                this.skillMtimes.set(info.location, info.mtime);
+                continue;
+            }
+            // Check in-memory cache
+            const unchanged = this.skillMtimes.get(info.location) === info.mtime &&
+                this.skills.some((s) => s.location === info.location);
+            if (unchanged)
+                continue;
+            try {
+                const raw = await readFile(info.location, "utf-8");
+                if (info.kind === "rule") {
+                    this.parseRuleFileForEmbed(raw, info, toEmbed);
+                }
+                else {
+                    this.parseSkillFileForEmbed(raw, info, toEmbed);
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        // Embed new/changed entries in one batch
+        if (toEmbed.length > 0) {
+            const flatQueries = toEmbed.flatMap((p) => p.queries);
+            const flatEmbeddings = await this.provider.embed(flatQueries);
+            let offset = 0;
+            for (const item of toEmbed) {
+                const embeddings = flatEmbeddings.slice(offset, offset + item.queries.length);
+                const skill = {
+                    name: item.name,
+                    description: item.description,
+                    location: item.location,
+                    type: item.type,
+                    embeddings,
+                    queries: item.queries,
+                    oneLiner: item.oneLiner,
+                };
+                const existing = this.skills.findIndex((s) => s.location === item.location);
+                if (existing >= 0)
+                    this.skills[existing] = skill;
+                else
+                    this.skills.push(skill);
+                // Update persistent cache
+                if (this.cache) {
+                    this.cache.skills[item.location] = toCachedSkill(skill, item.mtime);
+                }
+                offset += item.queries.length;
+            }
+        }
+        // Remove deleted entries (handle memory section keys like "path#SectionName")
+        this.skills = this.skills.filter((s) => {
+            const baseLocation = s.location.includes("#") ? s.location.split("#")[0] : s.location;
+            return currentLocations.has(baseLocation) || currentLocations.has(s.location);
+        });
+        // Clean cache of deleted entries
+        if (this.cache) {
+            for (const key of Object.keys(this.cache.skills)) {
+                const baseKey = key.includes("#") ? key.split("#")[0] : key;
+                if (!currentLocations.has(baseKey) && !currentLocations.has(key)) {
+                    delete this.cache.skills[key];
+                }
+            }
+        }
+        // Update mtime tracking
+        this.skillMtimes = new Map(statResults.map((s) => [s.location, s.mtime]));
+        // Persist cache (fire-and-forget)
+        if (this.cache && toEmbed.length > 0) {
+            saveCache(this.cachePath, this.cache).catch(() => {
+                // Cache save is best-effort
+            });
+        }
+        this.buildTime = Date.now();
+    }
+    /**
+     * Search the index for skills matching the query.
+     * Supports both relative and absolute scoring modes.
+     */
+    async search(query, topK, threshold, typeFilter, scoringMode = "absolute", maxDropoff = 0.15) {
+        let candidates = this.skills;
+        if (typeFilter && typeFilter.length > 0) {
+            const allowed = new Set(typeFilter);
+            candidates = candidates.filter((s) => allowed.has(s.type));
+        }
+        if (candidates.length === 0)
+            return [];
+        const [queryEmbedding] = await this.provider.embed([query]);
+        const scored = candidates.map((skill) => {
+            const similarities = skill.embeddings.map((e) => cosineSimilarity(queryEmbedding, e));
+            const score = Math.max(...similarities);
+            return { skill, score };
+        });
+        const sorted = scored.sort((a, b) => b.score - a.score);
+        if (scoringMode === "relative") {
+            // Relative mode: if the best match clears the floor, inject top-K
+            // but drop results that fall too far below the best
+            if (sorted.length === 0 || sorted[0].score < threshold)
+                return [];
+            const bestScore = sorted[0].score;
+            return sorted.filter((r) => bestScore - r.score <= maxDropoff).slice(0, topK);
+        }
+        // Absolute mode: each result must individually pass threshold
+        return sorted.filter((r) => r.score >= threshold).slice(0, topK);
+    }
+    /**
+     * Read the body content of a skill file, stripping frontmatter.
+     */
+    async readSkillContent(location) {
+        if (location.includes("#")) {
+            const [filePath, sectionName] = location.split("#", 2);
+            const raw = await readFile(filePath, "utf-8");
+            const sections = parseMemoryFile(raw, filePath);
+            const section = sections.find((s) => s.name === sectionName);
+            return section?.body.trim() || "";
+        }
+        const raw = await readFile(location, "utf-8");
+        const { body } = parseFrontmatter(raw);
+        return body.trim();
+    }
+    // -------------------------------------------------------------------------
+    // Private parsing helpers
+    // -------------------------------------------------------------------------
+    parseSkillFileForEmbed(raw, info, toEmbed) {
+        const { meta, body } = parseFrontmatter(raw);
+        if (!meta.name || !meta.description)
+            return;
+        const queries = meta.queries?.length ? meta.queries : [meta.description];
+        const type = meta.type || "skill";
+        toEmbed.push({
+            name: meta.name,
+            description: meta.description,
+            location: info.location,
+            queries,
+            type,
+            mtime: info.mtime,
+            body,
+            oneLiner: meta.oneLiner,
+        });
+    }
+    parseMemoryFileForEmbed(raw, info, toEmbed) {
+        const sections = parseMemoryFile(raw, info.location);
+        for (const section of sections) {
+            const key = `${info.location}#${section.name}`;
+            const queries = section.queries.length > 0 ? section.queries : [section.description];
+            toEmbed.push({
+                name: section.name,
+                description: section.description,
+                location: key,
+                queries,
+                type: "memory",
+                mtime: info.mtime,
+                body: section.body,
+            });
+        }
+    }
+    parseRuleFileForEmbed(raw, info, toEmbed) {
+        const { meta, body } = parseFrontmatter(raw);
+        const name = meta.name || basename(info.location, ".md");
+        const description = meta.description || body.split("\n")[0]?.trim() || name;
+        const oneLiner = meta.oneLiner || description;
+        const queries = [];
+        if (meta.queries?.length)
+            queries.push(...meta.queries);
+        if (meta.keywords?.length)
+            queries.push(...meta.keywords);
+        if (queries.length === 0)
+            queries.push(description);
+        toEmbed.push({
+            name,
+            description,
+            location: info.location,
+            queries,
+            type: "rule",
+            mtime: info.mtime,
+            body,
+            oneLiner,
+        });
+    }
+}
+//# sourceMappingURL=skill-index.js.map