@compr/opscontext-mcp 2.0.0

package/dist/license-sig.d.ts

@@ -0,0 +1,47 @@
+export declare const LICENSE_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAnWMq7ITUPmC/8yx9XmpYktaWmQtXDOx6R2nqSdibq+Y=\n-----END PUBLIC KEY-----";
+export declare const LICENSE_PUBKEY_FINGERPRINT = "12d0c34c917a47fbed99945d2b7fb439";
+export interface SignableLicensePayload {
+    key: string;
+    email: string;
+    plan: string;
+    machineId: string;
+    expiresAt: string;
+    deltaVersion: string;
+}
+/**
+ * Stable serialization of the signable payload. MUST stay byte-identical
+ * to the server-side canonicalPayload() in server/src/license-sig.ts.
+ * Tests on each side assert a known-input → known-output to catch drift.
+ */
+export declare function canonicalPayload(license: SignableLicensePayload): string;
+export type VerifyResult = {
+    ok: true;
+    mode: "ed25519";
+} | {
+    ok: true;
+    mode: "legacy-grandfathered";
+    warning: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Verify the Ed25519 signature on a license.
+ *
+ * Three outcomes:
+ *   - ok=true,  mode=ed25519              → signature valid, full trust
+ *   - ok=true,  mode=legacy-grandfathered → pre-Ed25519 SHA-256 hash
+ *                                            (64-hex shape); grandfathered
+ *                                            until the flag day so existing
+ *                                            licensees don't lose access
+ *                                            immediately
+ *   - ok=false, reason=<string>           → signature missing / invalid /
+ *                                            tampered / wrong keypair
+ *
+ * Override the public key via CE_LICENSE_PUBLIC_KEY env var (PEM contents)
+ * for self-hosters running their own activation server.
+ */
+export declare function verifyLicenseSignature(license: SignableLicensePayload & {
+    signature: string;
+}, publicKeyPem?: string): VerifyResult;
+//# sourceMappingURL=license-sig.d.ts.map

package/dist/license-sig.js

@@ -0,0 +1,104 @@
+// 🔒 LOCKED [LICENSE-SIG] — 2026-06-10
+// ⛔ NEVER change canonicalPayload()'s key order or field set without
+//    bumping a new "sig_v":2 marker AND keeping v1 verification working
+//    forever. The byte output of this function is what the Ed25519
+//    signature covers; any change breaks every license issued before
+//    the change.
+// ⛔ NEVER ship the public key as a mutable variable. It's a constant
+//    that pins the client to the production activation server.
+//    Self-hosters override via CE_LICENSE_PUBLIC_KEY env var, which
+//    is the documented escape hatch.
+// ⛔ NEVER reject legacy SHA-256 signatures silently. Today they're
+//    grandfathered with a one-line warning + audit event. The flag
+//    day for rejection is a SEPARATE commit, called out in CHANGELOG,
+//    and gives existing licensees 30+ days to reactivate.
+// WHY: Audit identified that loadLicense() did NOT verify the
+//    signature field — anyone could write ~/.contextengine/license.json
+//    with plan:"enterprise" and unlock all PRO tools. Security bug +
+//    revenue leak. This module closes it without breaking the ~95
+//    weekly install users who activated before this commit landed.
+// FIX: The PAIR of this file is server/src/license-sig.ts.
+//    `canonicalPayload()` must be byte-identical between the two.
+//    A test on each side asserts a known-input → known-output mapping
+//    to catch drift.
+//
+// Ed25519 license signature — verify side (client).
+//
+// Pairs with server/src/license-sig.ts (sign side). Public key below is
+// pinned to the production activation server (api.compr.ch). Self-hosters
+// override with CE_LICENSE_PUBLIC_KEY env var.
+import { createPublicKey, verify } from "crypto";
+// Production Ed25519 public key. Paired private key lives ONLY on the
+// activation server. Public key SHA-256 fingerprint (first 32 hex chars):
+//   12d0c34c917a47fbed99945d2b7fb439
+// (Recompute by running on the server:
+//   openssl pkey -in private.pem -pubout -outform DER | openssl dgst -sha256)
+export const LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAnWMq7ITUPmC/8yx9XmpYktaWmQtXDOx6R2nqSdibq+Y=
+-----END PUBLIC KEY-----`;
+export const LICENSE_PUBKEY_FINGERPRINT = "12d0c34c917a47fbed99945d2b7fb439";
+/**
+ * Stable serialization of the signable payload. MUST stay byte-identical
+ * to the server-side canonicalPayload() in server/src/license-sig.ts.
+ * Tests on each side assert a known-input → known-output to catch drift.
+ */
+export function canonicalPayload(license) {
+    return JSON.stringify({
+        key: license.key,
+        email: license.email,
+        plan: license.plan,
+        machineId: license.machineId,
+        expiresAt: license.expiresAt,
+        deltaVersion: license.deltaVersion,
+    });
+}
+/**
+ * Verify the Ed25519 signature on a license.
+ *
+ * Three outcomes:
+ *   - ok=true,  mode=ed25519              → signature valid, full trust
+ *   - ok=true,  mode=legacy-grandfathered → pre-Ed25519 SHA-256 hash
+ *                                            (64-hex shape); grandfathered
+ *                                            until the flag day so existing
+ *                                            licensees don't lose access
+ *                                            immediately
+ *   - ok=false, reason=<string>           → signature missing / invalid /
+ *                                            tampered / wrong keypair
+ *
+ * Override the public key via CE_LICENSE_PUBLIC_KEY env var (PEM contents)
+ * for self-hosters running their own activation server.
+ */
+export function verifyLicenseSignature(license, publicKeyPem = process.env.CE_LICENSE_PUBLIC_KEY || LICENSE_PUBLIC_KEY_PEM) {
+    if (!license.signature || license.signature.length === 0) {
+        return { ok: false, reason: "signature field missing" };
+    }
+    // Legacy detection: pre-Ed25519 signatures were SHA-256 hex (64 chars).
+    // Real Ed25519 signatures are 64 raw bytes → 88-char base64.
+    if (/^[a-f0-9]{64}$/.test(license.signature)) {
+        return {
+            ok: true,
+            mode: "legacy-grandfathered",
+            warning: "Legacy SHA-256 license signature accepted (grandfathered). Reactivate to get an Ed25519-signed license — pre-flag-day licenses will be rejected after the cutover.",
+        };
+    }
+    try {
+        const pubKey = createPublicKey(publicKeyPem);
+        const sigBytes = Buffer.from(license.signature, "base64");
+        const payload = Buffer.from(canonicalPayload(license));
+        const ok = verify(null, payload, pubKey, sigBytes);
+        if (!ok) {
+            return {
+                ok: false,
+                reason: "Ed25519 signature invalid (tampered license, wrong keypair, or canonical-payload drift)",
+            };
+        }
+        return { ok: true, mode: "ed25519" };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            reason: `signature verify error: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+}
+//# sourceMappingURL=license-sig.js.map

package/dist/policy.d.ts

@@ -0,0 +1,131 @@
+import { z } from "zod";
+/**
+ * A regex pattern the secret scanner should match against staged diff content.
+ * Optional `paths` glob list scopes the pattern (e.g. JWT pattern only
+ * applied to docs/sessions/**\/*.md, the Apec-leak shape).
+ */
+export declare const SecretPatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern: z.ZodString;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        warn: "warn";
+        block: "block";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SecretPattern = z.infer<typeof SecretPatternSchema>;
+/**
+ * A source-tree subtree that requires a documentation section to stay current.
+ * Diff-aware: the gate fires only when commit touches the mapped subtree AND
+ * the corresponding doc section's hash is unchanged. Replaces the 4-hour
+ * wall-clock timer from the legacy hook.
+ */
+export declare const DocCoverageSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+    requires_section: z.ZodString;
+    severity: z.ZodDefault<z.ZodEnum<{
+        warn: "warn";
+        block: "block";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DocCoverage = z.infer<typeof DocCoverageSchema>;
+/**
+ * A production host that requires a verification probe within N seconds of
+ * a git push. Encodes the "DEPLOY = VERIFY LIVE" rule from CLAUDE.md.
+ */
+export declare const DeployVerifyHostSchema: z.ZodObject<{
+    host: z.ZodString;
+    require_probe: z.ZodString;
+    within_seconds: z.ZodDefault<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DeployVerifyHost = z.infer<typeof DeployVerifyHostSchema>;
+/**
+ * A documented escape hatch for the hook. Beats undocumented `touch` /
+ * `--no-verify` workarounds. Bypass token requires a reason and lives in
+ * the audit log.
+ */
+export declare const BypassTokenSchema: z.ZodObject<{
+    id: z.ZodString;
+    ttl_seconds: z.ZodDefault<z.ZodNumber>;
+    requires_reason_min_length: z.ZodDefault<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BypassToken = z.infer<typeof BypassTokenSchema>;
+/**
+ * The full policy document — schema version 1.
+ */
+export declare const PolicySchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    extends: z.ZodOptional<z.ZodString>;
+    secret_patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pattern: z.ZodString;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        severity: z.ZodDefault<z.ZodEnum<{
+            warn: "warn";
+            block: "block";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    doc_coverage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+        requires_section: z.ZodString;
+        severity: z.ZodDefault<z.ZodEnum<{
+            warn: "warn";
+            block: "block";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    deploy_verify_hosts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        require_probe: z.ZodString;
+        within_seconds: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    bypass_tokens: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ttl_seconds: z.ZodDefault<z.ZodNumber>;
+        requires_reason_min_length: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Policy = z.infer<typeof PolicySchema>;
+/**
+ * Validate a raw parsed object against the policy schema. Returns either
+ * a validated Policy or a structured list of field-level errors.
+ */
+export type ValidationResult = {
+    ok: true;
+    policy: Policy;
+} | {
+    ok: false;
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export declare function validatePolicy(raw: unknown): ValidationResult;
+/**
+ * Parse policy file contents. Currently supports JSON only. YAML support
+ * is on the roadmap — purely an ergonomic addition, no runtime difference.
+ */
+export declare function parsePolicy(contents: string): ValidationResult;
+/**
+ * Load the repo-local policy from .contextengine/policy.json. Returns null
+ * when no policy file exists (repos without explicit policy still work —
+ * hooks fall back to built-in defaults).
+ *
+ * Returns ValidationResult so consumers can surface schema errors to the
+ * user instead of crashing on a malformed file.
+ */
+export declare function loadRepoPolicy(repoRoot: string): ValidationResult | null;
+export declare function repoPolicyPath(repoRoot: string): string;
+export declare function formatPolicySummary(policy: Policy): string;
+export declare function formatValidationErrors(errors: Array<{
+    path: string;
+    message: string;
+}>): string;
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.js

@@ -0,0 +1,182 @@
+// 🔒 LOCKED [POLICY-CONTRACT] — 2026-06-10
+// ⛔ NEVER bump `version: 1` without a migration path that keeps v1
+//    policies loadable. Org policy URLs in the wild will pin a version;
+//    breaking the loader silently breaks remote policy distribution.
+// ⛔ NEVER add NEW required fields to existing schemas — only optional
+//    fields with defaults. Old policies must still validate.
+// WHY: This is the contract that hooks, CI templates, and the future
+//    signed-policy-distribution layer will all consume. Schema breakage
+//    here cascades into every consumer. The audit's hook-redesign
+//    proposal hinges on this single declarative contract replacing 329
+//    LOC of inline bash.
+// FIX: To evolve, add `version: 2` schema alongside, dispatch in
+//    `parsePolicy()` based on the version field, keep `validatePolicy()`
+//    backward-compatible.
+//
+// Declarative policy contract — .contextengine/policy.json at repo root.
+//
+// Hooks (pre-commit, CC PreToolUse, CI templates) consume this single file
+// instead of carrying inline bash. Reviewable in PR, portable across IDE +
+// git + CI layers, signable as an org-distributed bundle later.
+import { z } from "zod";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+/**
+ * A regex pattern the secret scanner should match against staged diff content.
+ * Optional `paths` glob list scopes the pattern (e.g. JWT pattern only
+ * applied to docs/sessions/**\/*.md, the Apec-leak shape).
+ */
+export const SecretPatternSchema = z.object({
+    id: z.string().min(1).describe("Stable identifier for audit-log attribution"),
+    pattern: z.string().min(1).describe("ERE regex matched against added lines"),
+    paths: z.array(z.string()).optional().describe("Glob patterns scoping the rule; omit for all files"),
+    severity: z.enum(["block", "warn"]).default("block"),
+    description: z.string().optional(),
+});
+/**
+ * A source-tree subtree that requires a documentation section to stay current.
+ * Diff-aware: the gate fires only when commit touches the mapped subtree AND
+ * the corresponding doc section's hash is unchanged. Replaces the 4-hour
+ * wall-clock timer from the legacy hook.
+ */
+export const DocCoverageSchema = z.object({
+    paths: z.array(z.string()).min(1).describe("Source-tree globs that this rule covers"),
+    requires_section: z.string().min(1).describe("Doc path with anchor, e.g. SKILLS.md#protocol-firewall"),
+    severity: z.enum(["block", "warn"]).default("block"),
+    description: z.string().optional(),
+});
+/**
+ * A production host that requires a verification probe within N seconds of
+ * a git push. Encodes the "DEPLOY = VERIFY LIVE" rule from CLAUDE.md.
+ */
+export const DeployVerifyHostSchema = z.object({
+    host: z.string().min(1),
+    require_probe: z.string().min(1).describe("Shell command run to verify, e.g. curl -sf https://host/healthz"),
+    within_seconds: z.number().int().positive().default(60),
+    description: z.string().optional(),
+});
+/**
+ * A documented escape hatch for the hook. Beats undocumented `touch` /
+ * `--no-verify` workarounds. Bypass token requires a reason and lives in
+ * the audit log.
+ */
+export const BypassTokenSchema = z.object({
+    id: z.string().min(1).describe("Stable identifier for audit-log attribution"),
+    ttl_seconds: z.number().int().positive().default(300).describe("How long after issuance the token is valid"),
+    requires_reason_min_length: z.number().int().min(0).default(20),
+    description: z.string().optional(),
+});
+/**
+ * The full policy document — schema version 1.
+ */
+export const PolicySchema = z.object({
+    version: z.literal(1).describe("Policy schema version. Pin to 1 — bumps require a migration path."),
+    extends: z
+        .string()
+        .url()
+        .optional()
+        .describe("Org policy URL (HTTPS or git). Signed-bundle distribution is a P1 #5 follow-up."),
+    secret_patterns: z.array(SecretPatternSchema).default([]),
+    doc_coverage: z.array(DocCoverageSchema).default([]),
+    deploy_verify_hosts: z.array(DeployVerifyHostSchema).default([]),
+    bypass_tokens: z.array(BypassTokenSchema).default([]),
+});
+export function validatePolicy(raw) {
+    const result = PolicySchema.safeParse(raw);
+    if (result.success)
+        return { ok: true, policy: result.data };
+    return {
+        ok: false,
+        errors: result.error.issues.map((i) => ({
+            path: i.path.length ? i.path.join(".") : "(root)",
+            message: i.message,
+        })),
+    };
+}
+/**
+ * Parse policy file contents. Currently supports JSON only. YAML support
+ * is on the roadmap — purely an ergonomic addition, no runtime difference.
+ */
+export function parsePolicy(contents) {
+    let raw;
+    try {
+        raw = JSON.parse(contents);
+    }
+    catch (e) {
+        return {
+            ok: false,
+            errors: [{ path: "(root)", message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` }],
+        };
+    }
+    return validatePolicy(raw);
+}
+/**
+ * Load the repo-local policy from .contextengine/policy.json. Returns null
+ * when no policy file exists (repos without explicit policy still work —
+ * hooks fall back to built-in defaults).
+ *
+ * Returns ValidationResult so consumers can surface schema errors to the
+ * user instead of crashing on a malformed file.
+ */
+export function loadRepoPolicy(repoRoot) {
+    const path = repoPolicyPath(repoRoot);
+    if (!existsSync(path))
+        return null;
+    try {
+        const contents = readFileSync(path, "utf-8");
+        return parsePolicy(contents);
+    }
+    catch (e) {
+        return {
+            ok: false,
+            errors: [{ path: "(file)", message: `Cannot read ${path}: ${e instanceof Error ? e.message : String(e)}` }],
+        };
+    }
+}
+export function repoPolicyPath(repoRoot) {
+    return join(repoRoot, ".contextengine", "policy.json");
+}
+// ---------------------------------------------------------------------------
+// Pretty-print
+// ---------------------------------------------------------------------------
+export function formatPolicySummary(policy) {
+    const lines = [];
+    lines.push(`# ContextEngine policy (v${policy.version})`);
+    if (policy.extends) {
+        lines.push(`Extends: ${policy.extends}  (signed bundle resolution: not yet implemented — P1 #5)`);
+    }
+    lines.push("");
+    lines.push(`Secret patterns: ${policy.secret_patterns.length}`);
+    for (const p of policy.secret_patterns) {
+        const scope = p.paths?.length ? p.paths.join(", ") : "(all files)";
+        lines.push(`  - [${p.severity}] ${p.id} → scoped to ${scope}`);
+    }
+    lines.push("");
+    lines.push(`Doc coverage rules: ${policy.doc_coverage.length}`);
+    for (const c of policy.doc_coverage) {
+        lines.push(`  - [${c.severity}] ${c.paths.join(", ")} → ${c.requires_section}`);
+    }
+    lines.push("");
+    lines.push(`Deploy-verify hosts: ${policy.deploy_verify_hosts.length}`);
+    for (const h of policy.deploy_verify_hosts) {
+        lines.push(`  - ${h.host} → probe within ${h.within_seconds}s: ${h.require_probe}`);
+    }
+    lines.push("");
+    lines.push(`Bypass tokens: ${policy.bypass_tokens.length}`);
+    for (const b of policy.bypass_tokens) {
+        lines.push(`  - ${b.id} → TTL ${b.ttl_seconds}s, reason ≥ ${b.requires_reason_min_length} chars`);
+    }
+    return lines.join("\n");
+}
+export function formatValidationErrors(errors) {
+    const lines = [];
+    lines.push(`❌ Policy validation failed — ${errors.length} error(s):`);
+    for (const e of errors) {
+        lines.push(`  • ${e.path}: ${e.message}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=policy.js.map

package/dist/search.d.ts

@@ -0,0 +1,11 @@
+import { Chunk } from "./ingest.js";
+export interface SearchResult {
+    chunk: Chunk;
+    score: number;
+}
+/**
+ * Search chunks by BM25 keyword relevance.
+ * Returns top-k results sorted by score descending.
+ */
+export declare function searchChunks(chunks: Chunk[], query: string, topK?: number): SearchResult[];
+//# sourceMappingURL=search.d.ts.map

package/dist/search.js

@@ -0,0 +1,99 @@
+// LOCKED — verified March 3 2026 — BM25 keyword search with IDF + temporal decay + lock detection
+// DO NOT RE-AUDIT — scoring weights are IP-protected trade secrets
+/**
+ * BM25-style keyword search over chunks.
+ *
+ * v1.10: Upgraded from naive term-overlap to proper BM25 scoring with:
+ * - IDF (inverse document frequency) — rare terms score higher
+ * - Document length normalization — short focused chunks aren't penalized
+ * - Configurable k1 (term frequency saturation) and b (length penalty)
+ *
+ * Inspired by OpenClaw's FTS5/BM25 approach but pure JS (no SQLite dep).
+ */
+// BM25 parameters
+const K1 = 1.5; // Term frequency saturation (1.2-2.0 typical)
+const B = 0.75; // Length normalization factor (0 = no normalization, 1 = full)
+/** Normalize and tokenize a string */
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s_\-./]/g, " ")
+        .split(/\s+/)
+        .filter((t) => t.length > 1);
+}
+/** Count term occurrences in text */
+function termFrequency(tokens, term) {
+    return tokens.filter((t) => t === term || t.includes(term)).length;
+}
+/**
+ * Pre-compute IDF values for query terms across the corpus.
+ * IDF = log((N - n + 0.5) / (n + 0.5) + 1) where N = total docs, n = docs containing term
+ */
+function computeIDF(chunks, queryTokens) {
+    const N = chunks.length;
+    const idf = new Map();
+    for (const term of queryTokens) {
+        let docCount = 0;
+        for (const chunk of chunks) {
+            const text = (chunk.content + " " + chunk.section).toLowerCase();
+            if (text.includes(term)) {
+                docCount++;
+            }
+        }
+        // BM25 IDF formula
+        const val = Math.log((N - docCount + 0.5) / (docCount + 0.5) + 1);
+        idf.set(term, val);
+    }
+    return idf;
+}
+/**
+ * Score a chunk against query tokens using BM25.
+ */
+function bm25Score(chunk, queryTokens, idf, avgDl) {
+    const text = (chunk.content + " " + chunk.section).toLowerCase();
+    const docTokens = tokenize(text);
+    const dl = docTokens.length;
+    let score = 0;
+    for (const term of queryTokens) {
+        const tf = termFrequency(docTokens, term);
+        if (tf === 0)
+            continue;
+        const termIdf = idf.get(term) || 0;
+        // BM25 TF component: tf * (k1 + 1) / (tf + k1 * (1 - b + b * dl / avgDl))
+        const tfNorm = (tf * (K1 + 1)) / (tf + K1 * (1 - B + B * (dl / avgDl)));
+        score += termIdf * tfNorm;
+    }
+    // Bonus for matching multiple distinct query terms (proximity signal)
+    const distinctMatches = queryTokens.filter((t) => text.includes(t)).length;
+    if (distinctMatches > 1) {
+        score *= 1 + distinctMatches * 0.15;
+    }
+    return score;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Search chunks by BM25 keyword relevance.
+ * Returns top-k results sorted by score descending.
+ */
+export function searchChunks(chunks, query, topK = 10) {
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0)
+        return [];
+    // Pre-compute IDF and average document length
+    const idf = computeIDF(chunks, queryTokens);
+    const avgDl = chunks.reduce((sum, c) => {
+        return sum + tokenize((c.content + " " + c.section).toLowerCase()).length;
+    }, 0) / Math.max(chunks.length, 1);
+    const scored = [];
+    for (const chunk of chunks) {
+        const score = bm25Score(chunk, queryTokens, idf, avgDl);
+        if (score > 0) {
+            scored.push({ chunk, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK);
+}
+//# sourceMappingURL=search.js.map

package/dist/sessions.d.ts

@@ -0,0 +1,46 @@
+export interface SessionEntry {
+    key: string;
+    value: string;
+    timestamp: string;
+}
+export interface Session {
+    name: string;
+    created: string;
+    updated: string;
+    entries: SessionEntry[];
+}
+/**
+ * Save or update a key-value pair in a named session.
+ */
+export declare function saveSession(name: string, key: string, value: string): Session;
+/**
+ * Load a session by name.
+ */
+export declare function loadSession(name: string): Session | null;
+/**
+ * List all saved sessions.
+ */
+export declare function listSessions(): Array<{
+    name: string;
+    entries: number;
+    created: string;
+    updated: string;
+}>;
+/**
+ * Delete a session.
+ */
+export declare function deleteSession(name: string): boolean;
+/**
+ * Format a session for display.
+ */
+export declare function formatSession(session: Session): string;
+/**
+ * Format session list for display.
+ */
+export declare function formatSessionList(sessions: Array<{
+    name: string;
+    entries: number;
+    created: string;
+    updated: string;
+}>): string;
+//# sourceMappingURL=sessions.d.ts.map