@iamem/amem 0.1.0

package/dist/repo-identity.js

@@ -0,0 +1,82 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function runGit(cwd, args) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function findGitRoot(startPath = process.cwd()) {
+    const out = runGit(resolve(startPath), ["rev-parse", "--show-toplevel"]);
+    return out && existsSync(out) ? out : null;
+}
+/** Normalize remotes so ssh/https clones of the same repo share a key. */
+export function normalizeRemoteUrl(url) {
+    // Strip trailing slashes before ".git" so "repo.git/" still collapses to "repo".
+    let u = url.trim().replace(/\/+$/, "").replace(/\.git$/i, "");
+    const scp = /^git@([^:]+):(.+)$/.exec(u);
+    if (scp) {
+        u = `https://${scp[1]}/${scp[2]}`;
+    }
+    u = u.replace(/^ssh:\/\/git@/i, "https://");
+    u = u.replace(/^git:\/\//i, "https://");
+    u = u.replace(/^(https?:\/\/)[^@]+@/i, "$1");
+    return u.toLowerCase().replace(/\/+$/, "").replace(/\.git$/i, "");
+}
+export function detectRepoIdentity(cwd = process.cwd()) {
+    const rootPath = findGitRoot(cwd) ?? resolve(cwd);
+    const remoteRaw = runGit(rootPath, ["remote", "get-url", "origin"]);
+    const remoteUrl = remoteRaw ? normalizeRemoteUrl(remoteRaw) : null;
+    const defaultBranch = runGit(rootPath, ["symbolic-ref", "refs/remotes/origin/HEAD"])?.replace(/^refs\/remotes\/origin\//, "") ??
+        runGit(rootPath, ["rev-parse", "--abbrev-ref", "HEAD"]) ??
+        "main";
+    const repoName = remoteUrl?.split("/").filter(Boolean).pop() ??
+        rootPath.split(/[/\\]/).filter(Boolean).pop() ??
+        "repo";
+    const keySource = remoteUrl ?? `path:${rootPath}`;
+    const repoKey = createHash("sha256").update(keySource).digest("hex").slice(0, 16);
+    return {
+        rootPath,
+        remoteUrl,
+        repoKey,
+        repoName,
+        defaultBranch,
+    };
+}
+export function slugifyWorkspace(name) {
+    const slug = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!slug)
+        throw new Error("Workspace name must contain letters or numbers");
+    return slug;
+}
+export function workspaceIdentity(name, rootPath) {
+    const slug = slugifyWorkspace(name);
+    const repoKey = createHash("sha256").update(`workspace:${slug}`).digest("hex").slice(0, 16);
+    return {
+        rootPath: resolve(rootPath),
+        remoteUrl: `amem://workspace/${slug}`,
+        repoKey,
+        repoName: slug,
+        defaultBranch: "main",
+    };
+}
+export function parseWorkspaceSlug(remoteUrl) {
+    const m = /^amem:\/\/workspace\/([^/]+)$/.exec(remoteUrl ?? "");
+    return m?.[1] ?? null;
+}
+export function newId(prefix) {
+    const id = randomUUID();
+    return prefix ? `${prefix}_${id}` : id;
+}

package/dist/rules-sync.d.ts

@@ -0,0 +1,7 @@
+import { type RepoRow } from "./db.js";
+export declare function pinnedRulesPath(repoRoot: string): string;
+export declare function renderPinnedRules(repo: RepoRow): string;
+export declare function syncPinnedRules(repo: RepoRow): {
+    path: string;
+    pinned: number;
+};

package/dist/rules-sync.js

@@ -0,0 +1,47 @@
+/**
+ * Compile pinned facts into a local Cursor rule file.
+ * Default writes into the repo .cursor/rules folder. Memory DB is unchanged.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { listClaims } from "./db.js";
+import { parseAnchors } from "./freshness.js";
+import { FEATURE_RULES_SYNC, requireFeature } from "./license.js";
+export function pinnedRulesPath(repoRoot) {
+    return join(repoRoot, ".cursor", "rules", "amem-pinned.mdc");
+}
+export function renderPinnedRules(repo) {
+    const pinned = listClaims(repo.id).filter((c) => Number(c.pinned || 0) > 0);
+    const lines = [
+        "---",
+        "description: Pinned amem facts. Generated — review before committing.",
+        "alwaysApply: true",
+        "---",
+        "",
+        "<!-- Generated by amem. Contains no memory database. Safe to gitignore. -->",
+        "",
+        `# Pinned memory for ${repo.repo_name}`,
+        "",
+    ];
+    if (pinned.length === 0) {
+        lines.push("_No pinned facts._", "");
+    }
+    else {
+        for (const claim of pinned) {
+            const anchors = parseAnchors(claim.code_anchors);
+            const where = anchors.length ? ` — \`${anchors.join("`, `")}\`` : "";
+            lines.push(`- **${claim.kind}** ${claim.text.trim()}${where}`);
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function syncPinnedRules(repo) {
+    requireFeature(FEATURE_RULES_SYNC, "Cursor rule sync");
+    const path = pinnedRulesPath(repo.root_path);
+    mkdirSync(join(repo.root_path, ".cursor", "rules"), { recursive: true });
+    const body = renderPinnedRules(repo);
+    writeFileSync(path, body, "utf8");
+    const pinned = listClaims(repo.id).filter((c) => Number(c.pinned || 0) > 0).length;
+    return { path, pinned };
+}

package/dist/savings-export.d.ts

@@ -0,0 +1,49 @@
+export type SavingsExportInput = {
+    scope: string;
+    days: number;
+    repoName?: string;
+    generatedAt?: string;
+    aggregate: {
+        pricing?: {
+            usdPerMillionInputTokens?: number;
+            basis?: string;
+        };
+        totals?: {
+            queries?: number;
+            estimatedTokensSaved?: number;
+            estimatedUsdSaved?: number;
+            estimatedMsSaved?: number;
+            localHits?: number;
+            serverTrips?: number;
+            hitRate?: number;
+            avgLocalMs?: number | null;
+            anchorsAvoided?: number;
+        };
+        monthly?: {
+            estimatedTokensSaved?: number;
+            estimatedUsdSaved?: number;
+            estimatedMsSaved?: number;
+            queries?: number;
+            sampleQueries?: number;
+            trendDays?: number;
+        };
+        byPlatform?: Array<{
+            platform: string;
+            queries: number;
+            estimatedTokensSaved: number;
+            estimatedUsdSaved?: number;
+            localHits?: number;
+            serverTrips?: number;
+        }>;
+    };
+};
+export type SavingsExportJson = SavingsExportInput & {
+    disclaimer: string;
+    filenameBase: string;
+};
+export declare function savingsDisclaimer(): string;
+export declare function buildSavingsExport(input: SavingsExportInput): SavingsExportJson;
+export declare function formatSavingsMarkdown(report: SavingsExportJson): string;
+/** Minimal single-font PDF for expense-review printouts (no extra dependency). */
+export declare function buildTextPdf(title: string, body: string): Buffer;
+export declare function savingsPdf(report: SavingsExportJson): Buffer;

package/dist/savings-export.js

@@ -0,0 +1,141 @@
+import { estimateUsdSaved, USD_PER_MILLION_INPUT_TOKENS } from "./estimate.js";
+function stamp(iso) {
+    return (iso || new Date().toISOString()).replace(/[:.]/g, "-").slice(0, 19);
+}
+export function savingsDisclaimer() {
+    return "Proxy for avoided file reads / input tokens — not a Cursor or model bill. Money uses estimated tokens × $3/1M input (Sonnet-class). Hit rate counts keyword matches only.";
+}
+export function buildSavingsExport(input) {
+    const generatedAt = input.generatedAt || new Date().toISOString();
+    const filenameBase = `amem-savings-${input.scope}-${input.days}d-${stamp(generatedAt)}`;
+    return {
+        ...input,
+        generatedAt,
+        pricing: {
+            usdPerMillionInputTokens: input.aggregate.pricing?.usdPerMillionInputTokens ?? USD_PER_MILLION_INPUT_TOKENS,
+            basis: input.aggregate.pricing?.basis ?? "input",
+        },
+        disclaimer: savingsDisclaimer(),
+        filenameBase,
+    };
+}
+export function formatSavingsMarkdown(report) {
+    const t = report.aggregate.totals ?? {};
+    const m = report.aggregate.monthly ?? {};
+    const platforms = report.aggregate.byPlatform ?? [];
+    const hit = t.hitRate != null ? `${Math.round(t.hitRate * 100)}%` : "—";
+    const lines = [
+        `# amem savings report`,
+        ``,
+        `- Scope: ${report.scope}${report.repoName ? ` (${report.repoName})` : ""}`,
+        `- Window: ${report.days} days`,
+        `- Generated: ${report.generatedAt}`,
+        `- Disclaimer: ${report.disclaimer}`,
+        ``,
+        `## Totals`,
+        ``,
+        `| Metric | Value |`,
+        `| --- | --- |`,
+        `| Queries | ${t.queries ?? 0} |`,
+        `| Keyword hits / misses | ${t.localHits ?? 0} / ${t.serverTrips ?? 0} |`,
+        `| Hit rate | ${hit} |`,
+        `| Est. tokens saved | ${t.estimatedTokensSaved ?? 0} |`,
+        `| Est. USD saved | $${(t.estimatedUsdSaved ?? estimateUsdSaved(t.estimatedTokensSaved ?? 0)).toFixed(2)} |`,
+        `| Est. time saved (ms) | ${t.estimatedMsSaved ?? 0} |`,
+        `| Avg local lookup (ms) | ${t.avgLocalMs ?? "—"} |`,
+        `| Anchors avoided | ${t.anchorsAvoided ?? 0} |`,
+        ``,
+        `## Monthly projection`,
+        ``,
+        `- Est. tokens / month: ${m.estimatedTokensSaved ?? 0}`,
+        `- Est. $ / month: $${(m.estimatedUsdSaved ?? 0).toFixed(2)}`,
+        `- From ${m.sampleQueries ?? 0} calls over ${m.trendDays ?? 0} day(s)`,
+        ``,
+        `## By host`,
+        ``,
+    ];
+    if (platforms.length === 0)
+        lines.push(`(no usage yet)`);
+    for (const p of platforms) {
+        lines.push(`- ${p.platform}: ${p.queries} queries, ~${p.estimatedTokensSaved} tokens, ~$${(p.estimatedUsdSaved ?? 0).toFixed(2)}, ${p.localHits ?? 0} hits / ${p.serverTrips ?? 0} misses`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function pdfEscape(text) {
+    return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+}
+function wrapLine(line, width = 88) {
+    if (line.length <= width)
+        return [line || " "];
+    const out = [];
+    let rest = line;
+    while (rest.length > width) {
+        let cut = rest.lastIndexOf(" ", width);
+        if (cut < 40)
+            cut = width;
+        out.push(rest.slice(0, cut));
+        rest = rest.slice(cut).trimStart();
+    }
+    if (rest)
+        out.push(rest);
+    return out;
+}
+/** Minimal single-font PDF for expense-review printouts (no extra dependency). */
+export function buildTextPdf(title, body) {
+    const wrapped = body.split("\n").flatMap((line) => wrapLine(line));
+    const perPage = 58;
+    const pages = [];
+    for (let i = 0; i < wrapped.length; i += perPage) {
+        pages.push(wrapped.slice(i, i + perPage));
+    }
+    if (pages.length === 0)
+        pages.push([title]);
+    const objs = [];
+    const add = (bodyObj) => {
+        objs.push(bodyObj);
+        return objs.length;
+    };
+    add("<< /Type /Catalog /Pages 2 0 R >>");
+    const pageIds = [];
+    const contentIds = [];
+    for (let i = 0; i < pages.length; i++) {
+        contentIds.push(0);
+        pageIds.push(0);
+    }
+    add("PLACEHOLDER_PAGES");
+    const fontId = add("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>");
+    for (let i = 0; i < pages.length; i++) {
+        const lines = pages[i];
+        const stream = [
+            "BT",
+            "/F1 11 Tf",
+            "50 742 Td",
+            "14 TL",
+            ...lines.map((line, idx) => `${idx === 0 ? "" : "T* "}(${pdfEscape(line)}) Tj`),
+            "ET",
+        ].join("\n");
+        const contentId = add(`<< /Length ${Buffer.byteLength(stream, "utf8")} >>\nstream\n${stream}\nendstream`);
+        contentIds[i] = contentId;
+        const pageId = add(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents ${contentId} 0 R /Resources << /Font << /F1 ${fontId} 0 R >> >> >>`);
+        pageIds[i] = pageId;
+    }
+    objs[1] = `<< /Type /Pages /Kids [${pageIds.map((id) => `${id} 0 R`).join(" ")}] /Count ${pageIds.length} >>`;
+    const chunks = [Buffer.from("%PDF-1.4\n")];
+    const offsets = [0];
+    for (let i = 0; i < objs.length; i++) {
+        offsets.push(chunks.reduce((n, c) => n + c.length, 0));
+        chunks.push(Buffer.from(`${i + 1} 0 obj\n${objs[i]}\nendobj\n`));
+    }
+    const xrefAt = chunks.reduce((n, c) => n + c.length, 0);
+    let xref = `xref\n0 ${objs.length + 1}\n0000000000 65535 f \n`;
+    for (let i = 1; i <= objs.length; i++) {
+        xref += `${String(offsets[i]).padStart(10, "0")} 00000 n \n`;
+    }
+    chunks.push(Buffer.from(xref));
+    chunks.push(Buffer.from(`trailer\n<< /Size ${objs.length + 1} /Root 1 0 R >>\nstartxref\n${xrefAt}\n%%EOF\n`));
+    return Buffer.concat(chunks);
+}
+export function savingsPdf(report) {
+    return buildTextPdf("amem savings report", formatSavingsMarkdown(report));
+}

package/dist/scan.d.ts

@@ -0,0 +1,16 @@
+export type ScannedRepo = {
+    name: string;
+    path: string;
+    remote: string | null;
+};
+export declare function scanRoots(): string[];
+export declare function scanGitRepos(options?: {
+    roots?: string[];
+    maxDepth?: number;
+    limit?: number;
+    timeoutMs?: number;
+}): {
+    repos: ScannedRepo[];
+    truncated: boolean;
+    scannedRoots: string[];
+};

package/dist/scan.js

@@ -0,0 +1,109 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+const SKIP_DIRS = new Set([
+    ".cache",
+    ".cursor",
+    ".git",
+    ".local",
+    ".npm",
+    ".nvm",
+    ".Trash",
+    "Applications",
+    "Library",
+    "Movies",
+    "Music",
+    "Pictures",
+    "Public",
+    "Caches",
+    "DerivedData",
+    "Downloads",
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    "Pods",
+    "tmp",
+]);
+function isGitRepo(dir) {
+    return existsSync(join(dir, ".git"));
+}
+function readRemote(repoRoot) {
+    try {
+        let gitPath = join(repoRoot, ".git");
+        const st = statSync(gitPath);
+        if (st.isFile()) {
+            const raw = readFileSync(gitPath, "utf8");
+            const m = /gitdir:\s*(.+)/i.exec(raw);
+            if (!m)
+                return null;
+            gitPath = resolve(repoRoot, m[1].trim());
+        }
+        const config = readFileSync(join(gitPath, "config"), "utf8");
+        const origin = /\[remote "origin"\][^\[]*url\s*=\s*(.+)/.exec(config);
+        return origin?.[1]?.trim() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function walk(dir, depth, maxDepth, limit, out, deadline) {
+    if (out.length >= limit || Date.now() > deadline)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    if (isGitRepo(dir)) {
+        out.push({
+            name: basename(dir),
+            path: dir,
+            remote: readRemote(dir),
+        });
+        return;
+    }
+    if (depth >= maxDepth)
+        return;
+    for (const entry of entries) {
+        if (out.length >= limit || Date.now() > deadline)
+            return;
+        if (!entry.isDirectory() || entry.isSymbolicLink())
+            continue;
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+            continue;
+        walk(join(dir, entry.name), depth + 1, maxDepth, limit, out, deadline);
+    }
+}
+export function scanRoots() {
+    const fromEnv = process.env.AMEM_SCAN_ROOTS;
+    if (fromEnv) {
+        return fromEnv
+            .split(":")
+            .map((p) => p.trim())
+            .filter(Boolean);
+    }
+    const home = homedir();
+    return [home];
+}
+export function scanGitRepos(options = {}) {
+    const roots = (options.roots ?? scanRoots()).filter((p) => existsSync(p));
+    const maxDepth = options.maxDepth ?? 5;
+    const limit = options.limit ?? 150;
+    const deadline = Date.now() + (options.timeoutMs ?? 8000);
+    const found = [];
+    for (const root of roots) {
+        walk(resolve(root), 0, maxDepth, limit, found, deadline);
+    }
+    found.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+    return {
+        repos: found,
+        truncated: found.length >= limit || Date.now() > deadline,
+        scannedRoots: roots,
+    };
+}

package/dist/search.d.ts

@@ -0,0 +1,25 @@
+import type Database from "better-sqlite3";
+import type { ClaimRow } from "./db.js";
+/** Tokenize for keyword fallback / conflict heuristics. */
+export declare function tokenize(text: string): string[];
+/** Build a safe FTS5 MATCH string from a free-text query (OR of quoted terms). */
+export declare function buildFtsMatchQuery(query: string): string | null;
+export declare function ensureClaimsFts(db: Database.Database): void;
+export declare function upsertClaimFts(db: Database.Database, claim: ClaimRow): void;
+export declare function removeClaimFts(db: Database.Database, repoId: string, claimId: string): void;
+export declare function reindexRepoClaimsFts(db: Database.Database, repoId: string): void;
+export declare function reindexAllClaimsFts(db: Database.Database): void;
+export type FtsHit = {
+    id: string;
+    bm25: number;
+};
+/**
+ * Rank active claims via FTS5 + bm25 (more negative = better).
+ * Returns empty on MATCH errors or empty query.
+ */
+export declare function searchClaimsFts(db: Database.Database, repoId: string, query: string, limit?: number): FtsHit[];
+/** Convert bm25 (lower/more negative is better) into a positive boost. */
+export declare function ftsBoostFromBm25(bm25: number): number;
+export declare function keywordScoreClaim(claim: ClaimRow, queryTokens: string[]): number;
+/** Jaccard similarity over token sets (0–1). */
+export declare function tokenJaccard(a: string, b: string): number;

package/dist/search.js

@@ -0,0 +1,150 @@
+const FTS_TABLE = "claims_fts";
+const FTS_MAP = "claims_fts_map";
+/** Tokenize for keyword fallback / conflict heuristics. */
+export function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9_./-]+/)
+        .filter((t) => t.length > 1);
+}
+/** Build a safe FTS5 MATCH string from a free-text query (OR of quoted terms). */
+export function buildFtsMatchQuery(query) {
+    const tokens = tokenize(query)
+        .map((t) => t.replace(/"/g, "").replace(/'/g, ""))
+        .filter((t) => t.length > 1 && !/^[.]+$/.test(t));
+    if (tokens.length === 0)
+        return null;
+    // Cap terms so pathological queries stay cheap
+    const terms = tokens.slice(0, 12).map((t) => `"${t}"`);
+    return terms.join(" OR ");
+}
+export function ensureClaimsFts(db) {
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS ${FTS_TABLE} USING fts5(
+      kind,
+      text,
+      anchors,
+      id_text,
+      repo_id UNINDEXED,
+      claim_id UNINDEXED,
+      tokenize = 'porter unicode61'
+    );
+    CREATE TABLE IF NOT EXISTS ${FTS_MAP} (
+      repo_id TEXT NOT NULL,
+      claim_id TEXT NOT NULL,
+      fts_rowid INTEGER NOT NULL,
+      PRIMARY KEY (repo_id, claim_id)
+    );
+  `);
+}
+function deleteFtsRow(db, repoId, claimId) {
+    const mapped = db
+        .prepare(`SELECT fts_rowid AS rowid FROM ${FTS_MAP} WHERE repo_id = ? AND claim_id = ?`)
+        .get(repoId, claimId);
+    if (!mapped)
+        return;
+    db.prepare(`DELETE FROM ${FTS_TABLE} WHERE rowid = ?`).run(mapped.rowid);
+    db.prepare(`DELETE FROM ${FTS_MAP} WHERE repo_id = ? AND claim_id = ?`).run(repoId, claimId);
+}
+export function upsertClaimFts(db, claim) {
+    if ((claim.status ?? "active") !== "active") {
+        deleteFtsRow(db, claim.repo_id, claim.id);
+        return;
+    }
+    deleteFtsRow(db, claim.repo_id, claim.id);
+    const result = db
+        .prepare(`INSERT INTO ${FTS_TABLE} (kind, text, anchors, id_text, repo_id, claim_id)
+       VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(claim.kind, claim.text, claim.code_anchors, claim.id, claim.repo_id, claim.id);
+    const rowid = Number(result.lastInsertRowid);
+    db.prepare(`INSERT INTO ${FTS_MAP} (repo_id, claim_id, fts_rowid) VALUES (?, ?, ?)`).run(claim.repo_id, claim.id, rowid);
+}
+export function removeClaimFts(db, repoId, claimId) {
+    deleteFtsRow(db, repoId, claimId);
+}
+export function reindexRepoClaimsFts(db, repoId) {
+    const mapped = db
+        .prepare(`SELECT claim_id, fts_rowid FROM ${FTS_MAP} WHERE repo_id = ?`)
+        .all(repoId);
+    for (const row of mapped) {
+        db.prepare(`DELETE FROM ${FTS_TABLE} WHERE rowid = ?`).run(row.fts_rowid);
+    }
+    db.prepare(`DELETE FROM ${FTS_MAP} WHERE repo_id = ?`).run(repoId);
+    const claims = db
+        .prepare(`SELECT * FROM claims WHERE repo_id = ? AND COALESCE(status, 'active') = 'active'`)
+        .all(repoId);
+    for (const claim of claims) {
+        upsertClaimFts(db, claim);
+    }
+}
+export function reindexAllClaimsFts(db) {
+    const mapped = db
+        .prepare(`SELECT fts_rowid FROM ${FTS_MAP}`)
+        .all();
+    for (const row of mapped) {
+        try {
+            db.prepare(`DELETE FROM ${FTS_TABLE} WHERE rowid = ?`).run(row.fts_rowid);
+        }
+        catch {
+            // ignore missing row
+        }
+    }
+    db.exec(`DELETE FROM ${FTS_MAP}`);
+    const repos = db.prepare(`SELECT id FROM repos`).all();
+    for (const r of repos) {
+        reindexRepoClaimsFts(db, r.id);
+    }
+}
+/**
+ * Rank active claims via FTS5 + bm25 (more negative = better).
+ * Returns empty on MATCH errors or empty query.
+ */
+export function searchClaimsFts(db, repoId, query, limit = 24) {
+    const match = buildFtsMatchQuery(query);
+    if (!match)
+        return [];
+    try {
+        return db
+            .prepare(`SELECT claim_id AS id, bm25(${FTS_TABLE}) AS bm25
+         FROM ${FTS_TABLE}
+         WHERE ${FTS_TABLE} MATCH ? AND repo_id = ?
+         ORDER BY bm25
+         LIMIT ?`)
+            .all(match, repoId, limit);
+    }
+    catch {
+        return [];
+    }
+}
+/** Convert bm25 (lower/more negative is better) into a positive boost. */
+export function ftsBoostFromBm25(bm25) {
+    return 18 / (1 + Math.abs(bm25));
+}
+export function keywordScoreClaim(claim, queryTokens) {
+    if (queryTokens.length === 0)
+        return 0;
+    const hay = `${claim.id} ${claim.kind} ${claim.text} ${claim.code_anchors}`.toLowerCase();
+    let score = 0;
+    for (const token of queryTokens) {
+        if (hay.includes(token)) {
+            score += token.length > 4 ? 3 : 2;
+            if (claim.text.toLowerCase().includes(token))
+                score += 1;
+            if (claim.id.toLowerCase().includes(token))
+                score += 2;
+        }
+    }
+    return score;
+}
+/** Jaccard similarity over token sets (0–1). */
+export function tokenJaccard(a, b) {
+    const sa = new Set(tokenize(a));
+    const sb = new Set(tokenize(b));
+    if (sa.size === 0 || sb.size === 0)
+        return 0;
+    let inter = 0;
+    for (const t of sa)
+        if (sb.has(t))
+            inter += 1;
+    return inter / (sa.size + sb.size - inter);
+}

package/dist/service.d.ts

@@ -0,0 +1,20 @@
+export declare const SERVICE_LABEL = "co.amem.ui";
+export declare const SYSTEMD_UNIT = "amem-ui.service";
+export type ServicePlatform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function servicePlatform(): ServicePlatform;
+export declare function isServiceSupported(): boolean;
+export declare function launchAgentPath(): string;
+export declare function systemdUserUnitPath(): string;
+export declare function windowsStartupCmdPath(): string;
+export declare function serviceInstallPath(): string;
+export declare function isServiceInstalled(): boolean;
+export declare function installLoginService(): {
+    path: string;
+    installed: boolean;
+    platform: ServicePlatform;
+};
+export declare function uninstallLoginService(): {
+    path: string;
+    installed: boolean;
+    platform: ServicePlatform;
+};