@exaudeus/memory-mcp 0.1.0

package/dist/text-analyzer.d.ts

@@ -0,0 +1,32 @@
+/** Parsed filter group: a set of required terms and excluded terms */
+export interface FilterGroup {
+    readonly must: Set<string>;
+    readonly mustNot: Set<string>;
+}
+/** Naive stem: strip common English suffixes to improve keyword matching.
+ *  "reducers" -> "reducer", "sealed" stays, "implementations" -> "implement" */
+export declare function stem(word: string): string;
+/** Extract significant keywords from text, with naive stemming.
+ *  Hyphenated words produce both the compound and its parts:
+ *  "memory-mcp" -> ["memory-mcp", "memory", "mcp"] */
+export declare function extractKeywords(text: string): Set<string>;
+/** Jaccard similarity: |intersection| / |union| */
+export declare function jaccardSimilarity(a: Set<string>, b: Set<string>): number;
+/** Containment similarity: |intersection| / min(|a|, |b|)
+ *  Catches when one entry is a subset of a larger one */
+export declare function containmentSimilarity(a: Set<string>, b: Set<string>): number;
+/** Combined similarity: max(jaccard, containment) with title boost.
+ *  Title keywords get double weight by being included twice. */
+export declare function similarity(titleA: string, contentA: string, titleB: string, contentB: string): number;
+/** Parse a filter string into OR groups of AND/NOT terms.
+ *  "reducer sealed|MVI -deprecated" -> [
+ *    { must: ["reducer", "seal"], mustNot: [] },
+ *    { must: ["mvi"], mustNot: ["deprecat"] }
+ *  ] */
+export declare function parseFilter(filter: string): FilterGroup[];
+/** Check if a set of keywords matches a filter string using stemmed AND/OR/NOT logic.
+ *  Entry matches if ANY OR-group is satisfied (all must-terms present, no mustNot-terms present). */
+export declare function matchesFilter(allKeywords: Set<string>, filter: string): boolean;
+/** Compute relevance score for an entry against a filter.
+ *  Title matches get 2x weight over content-only matches. */
+export declare function computeRelevanceScore(titleKeywords: Set<string>, contentKeywords: Set<string>, confidence: number, filter: string): number;

package/dist/text-analyzer.js

@@ -0,0 +1,190 @@
+// Pure text analysis: stemming, keyword extraction, similarity, filter parsing.
+// Stateless — all functions are pure. No I/O, no side effects.
+//
+// Design: this module is the seam for future search strategies.
+// v1: keyword matching with naive stemming (this file)
+// v2: spreading activation over a knowledge graph
+// v3: embedding-based cosine similarity
+// Stopwords for keyword extraction — common English words with no semantic value
+const STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'shall', 'can', 'to', 'of', 'in', 'for',
+    'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
+    'before', 'after', 'and', 'but', 'or', 'nor', 'not', 'so', 'yet',
+    'both', 'either', 'neither', 'each', 'every', 'all', 'any', 'few',
+    'more', 'most', 'other', 'some', 'such', 'no', 'only', 'own', 'same',
+    'than', 'too', 'very', 'just', 'because', 'if', 'when', 'where',
+    'how', 'what', 'which', 'who', 'whom', 'this', 'that', 'these',
+    'those', 'it', 'its', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'him', 'his', 'she', 'her', 'they', 'them', 'their', 'about',
+    'up', 'out', 'then', 'also', 'use', 'used', 'using',
+]);
+/** Naive stem: strip common English suffixes to improve keyword matching.
+ *  "reducers" -> "reducer", "sealed" stays, "implementations" -> "implement" */
+export function stem(word) {
+    if (word.length <= 4)
+        return word;
+    // Order matters: longest suffixes first
+    if (word.endsWith('ations'))
+        return word.slice(0, -6);
+    if (word.endsWith('tion'))
+        return word.slice(0, -4);
+    if (word.endsWith('ment'))
+        return word.slice(0, -4);
+    if (word.endsWith('ness'))
+        return word.slice(0, -4);
+    if (word.endsWith('ings'))
+        return word.slice(0, -4);
+    if (word.endsWith('ally'))
+        return word.slice(0, -4);
+    if (word.endsWith('ing'))
+        return word.slice(0, -3);
+    if (word.endsWith('ies'))
+        return word.slice(0, -3) + 'y';
+    if (word.endsWith('ers'))
+        return word.slice(0, -1);
+    if (word.endsWith('ted'))
+        return word.slice(0, -2);
+    if (word.endsWith('es') && word.length > 4)
+        return word.slice(0, -2);
+    if (word.endsWith('ed') && word.length > 4)
+        return word.slice(0, -2);
+    if (word.endsWith('ly') && word.length > 4)
+        return word.slice(0, -2);
+    if (word.endsWith('s') && !word.endsWith('ss') && word.length > 4)
+        return word.slice(0, -1);
+    return word;
+}
+/** Extract significant keywords from text, with naive stemming.
+ *  Hyphenated words produce both the compound and its parts:
+ *  "memory-mcp" -> ["memory-mcp", "memory", "mcp"] */
+export function extractKeywords(text) {
+    const words = text.toLowerCase()
+        .replace(/[^a-z0-9\s_-]/g, ' ') // strip punctuation
+        .split(/\s+/)
+        .filter(w => w.length > 2) // skip tiny words
+        .filter(w => !STOPWORDS.has(w));
+    // Expand hyphenated words: keep compound + add individual parts
+    const expanded = [];
+    for (const w of words) {
+        expanded.push(w);
+        if (w.includes('-')) {
+            for (const part of w.split('-')) {
+                if (part.length > 2 && !STOPWORDS.has(part)) {
+                    expanded.push(part);
+                }
+            }
+        }
+    }
+    return new Set(expanded.map(w => stem(w)));
+}
+/** Jaccard similarity: |intersection| / |union| */
+export function jaccardSimilarity(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const word of a) {
+        if (b.has(word))
+            intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+/** Containment similarity: |intersection| / min(|a|, |b|)
+ *  Catches when one entry is a subset of a larger one */
+export function containmentSimilarity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const word of a) {
+        if (b.has(word))
+            intersection++;
+    }
+    return intersection / Math.min(a.size, b.size);
+}
+/** Combined similarity: max(jaccard, containment) with title boost.
+ *  Title keywords get double weight by being included twice. */
+export function similarity(titleA, contentA, titleB, contentB) {
+    // Title keywords counted twice (implicit weight boost)
+    const kwA = extractKeywords(`${titleA} ${titleA} ${contentA}`);
+    const kwB = extractKeywords(`${titleB} ${titleB} ${contentB}`);
+    const jaccard = jaccardSimilarity(kwA, kwB);
+    const containment = containmentSimilarity(kwA, kwB);
+    return Math.max(jaccard, containment);
+}
+/** Parse a filter string into OR groups of AND/NOT terms.
+ *  "reducer sealed|MVI -deprecated" -> [
+ *    { must: ["reducer", "seal"], mustNot: [] },
+ *    { must: ["mvi"], mustNot: ["deprecat"] }
+ *  ] */
+export function parseFilter(filter) {
+    const orGroups = filter.split('|').map(g => g.trim()).filter(g => g.length > 0);
+    if (orGroups.length === 0)
+        return [];
+    return orGroups.map(group => {
+        const terms = group.split(/\s+/).filter(t => t.length > 0);
+        const must = new Set();
+        const mustNot = new Set();
+        for (const term of terms) {
+            if (term.startsWith('-') && term.length > 1) {
+                // Negation: stem the compound as-is, WITHOUT hyphen expansion.
+                // "-memory-mcp" excludes the compound "memory-mcp" only,
+                // not standalone "memory" or "mcp".
+                const raw = term.slice(1).toLowerCase().replace(/[^a-z0-9_-]/g, '');
+                if (raw.length > 2)
+                    mustNot.add(stem(raw));
+            }
+            else {
+                // Positive terms: full expansion (hyphens split into parts)
+                for (const kw of extractKeywords(term)) {
+                    must.add(kw);
+                }
+            }
+        }
+        return { must, mustNot };
+    });
+}
+/** Check if a set of keywords matches a filter string using stemmed AND/OR/NOT logic.
+ *  Entry matches if ANY OR-group is satisfied (all must-terms present, no mustNot-terms present). */
+export function matchesFilter(allKeywords, filter) {
+    const groups = parseFilter(filter);
+    if (groups.length === 0)
+        return true;
+    return groups.some(({ must, mustNot }) => {
+        for (const term of must) {
+            if (!allKeywords.has(term))
+                return false;
+        }
+        for (const term of mustNot) {
+            if (allKeywords.has(term))
+                return false;
+        }
+        return must.size > 0 || mustNot.size > 0;
+    });
+}
+/** Compute relevance score for an entry against a filter.
+ *  Title matches get 2x weight over content-only matches. */
+export function computeRelevanceScore(titleKeywords, contentKeywords, confidence, filter) {
+    const groups = parseFilter(filter);
+    if (groups.length === 0)
+        return 0;
+    let bestScore = 0;
+    for (const { must } of groups) {
+        if (must.size === 0)
+            continue;
+        let score = 0;
+        for (const term of must) {
+            if (titleKeywords.has(term)) {
+                score += 2.0; // title match = 2x weight
+            }
+            else if (contentKeywords.has(term)) {
+                score += 1.0; // content-only match
+            }
+        }
+        const normalized = score / must.size;
+        if (normalized > bestScore)
+            bestScore = normalized;
+    }
+    return bestScore * confidence;
+}

package/dist/thresholds.d.ts

@@ -0,0 +1,39 @@
+/** Minimum similarity score for dedup detection at write time (same-topic). */
+export declare const DEDUP_SIMILARITY_THRESHOLD = 0.35;
+/** Minimum similarity score for conflict detection at query time — same topic.
+ *  Higher threshold since same-topic overlaps are often legitimate variations. */
+export declare const CONFLICT_SIMILARITY_THRESHOLD_SAME_TOPIC = 0.6;
+/** Minimum similarity score for conflict detection at query time — cross topic.
+ *  Lower threshold: if entries in different topics overlap this much, they're
+ *  likely talking about the same architectural decision, which is suspicious. */
+export declare const CONFLICT_SIMILARITY_THRESHOLD_CROSS_TOPIC = 0.42;
+/** Minimum similarity score for surfacing relevant preferences (cross-topic). */
+export declare const PREFERENCE_SURFACE_THRESHOLD = 0.2;
+/** Minimum content length (chars) for conflict detection — short entries are too noisy. */
+export declare const CONFLICT_MIN_CONTENT_CHARS = 50;
+/** Opposition keyword pairs for enhanced conflict detection.
+ *  When entries overlap AND use opposing terms, boost the conflict signal. */
+export declare const OPPOSITION_PAIRS: ReadonlyArray<readonly [string, string]>;
+/** Score multiplier when a reference path basename matches the context keywords. */
+export declare const REFERENCE_BOOST_MULTIPLIER = 1.3;
+/** Per-topic scoring boost factors for contextSearch().
+ *  Higher = more likely to surface for any given context. */
+export declare const TOPIC_BOOST: Record<string, number>;
+/** Boost for module-scoped topics not in TOPIC_BOOST. */
+export declare const MODULE_TOPIC_BOOST = 1.1;
+/** User entry score when included by default (no keyword match). */
+export declare const USER_ALWAYS_INCLUDE_SCORE_FRACTION = 0.5;
+/** Days since lastAccessed before a standard entry (arch, conv, gotchas, etc.) goes stale. */
+export declare const DEFAULT_STALE_DAYS_STANDARD = 30;
+/** Days since lastAccessed before a preferences entry goes stale.
+ *  Longer than standard because coding preferences evolve slowly. */
+export declare const DEFAULT_STALE_DAYS_PREFERENCES = 90;
+/** Maximum stale entries surfaced in a single briefing.
+ *  Keeps the briefing actionable without overwhelming the agent. */
+export declare const DEFAULT_MAX_STALE_IN_BRIEFING = 5;
+/** Maximum dedup suggestions returned when storing a new entry. */
+export declare const DEFAULT_MAX_DEDUP_SUGGESTIONS = 3;
+/** Maximum conflict pairs surfaced per query/context response. */
+export declare const DEFAULT_MAX_CONFLICT_PAIRS = 2;
+/** Maximum related preferences surfaced when storing a non-preference entry. */
+export declare const DEFAULT_MAX_PREFERENCE_SUGGESTIONS = 3;

package/dist/thresholds.js

@@ -0,0 +1,75 @@
+// Central threshold definitions for the memory MCP.
+//
+// Split into two categories intentionally:
+//
+//   INTERNAL — calibrated against the text-analyzer algorithm (Jaccard + containment hybrid).
+//   Changing these without understanding the similarity function produces confusing results.
+//   Not exposed to users.
+//
+//   USER-FACING — control how the system behaves for the user's workflow.
+//   Exposed via memory-config.json under a top-level "behavior" key.
+//   All have sensible defaults; the user only needs to set what they want to change.
+// ─── Internal algorithm thresholds ─────────────────────────────────────────
+// These are properties of the similarity function, not user preferences.
+/** Minimum similarity score for dedup detection at write time (same-topic). */
+export const DEDUP_SIMILARITY_THRESHOLD = 0.35;
+/** Minimum similarity score for conflict detection at query time — same topic.
+ *  Higher threshold since same-topic overlaps are often legitimate variations. */
+export const CONFLICT_SIMILARITY_THRESHOLD_SAME_TOPIC = 0.60;
+/** Minimum similarity score for conflict detection at query time — cross topic.
+ *  Lower threshold: if entries in different topics overlap this much, they're
+ *  likely talking about the same architectural decision, which is suspicious. */
+export const CONFLICT_SIMILARITY_THRESHOLD_CROSS_TOPIC = 0.42;
+/** Minimum similarity score for surfacing relevant preferences (cross-topic). */
+export const PREFERENCE_SURFACE_THRESHOLD = 0.20;
+/** Minimum content length (chars) for conflict detection — short entries are too noisy. */
+export const CONFLICT_MIN_CONTENT_CHARS = 50;
+/** Opposition keyword pairs for enhanced conflict detection.
+ *  When entries overlap AND use opposing terms, boost the conflict signal. */
+export const OPPOSITION_PAIRS = [
+    ['use', 'avoid'],
+    ['always', 'never'],
+    ['prefer', 'avoid'],
+    ['required', 'forbidden'],
+    ['mandatory', 'optional'],
+    ['sync', 'async'],
+    ['mutable', 'immutable'],
+    ['mvi', 'mvvm'],
+    ['sealed class', 'sealed interface'],
+    ['inheritance', 'composition'],
+    ['throw', 'return'], // exceptions vs Result types
+    ['imperative', 'declarative'],
+];
+/** Score multiplier when a reference path basename matches the context keywords. */
+export const REFERENCE_BOOST_MULTIPLIER = 1.30;
+/** Per-topic scoring boost factors for contextSearch().
+ *  Higher = more likely to surface for any given context. */
+export const TOPIC_BOOST = {
+    user: 2.0, // always surface identity
+    preferences: 1.8, // almost always relevant
+    gotchas: 1.5, // high-value warnings
+    conventions: 1.2, // coding patterns
+    architecture: 1.0, // baseline
+    'recent-work': 0.9, // slightly deprioritized (branch-filtered separately)
+};
+/** Boost for module-scoped topics not in TOPIC_BOOST. */
+export const MODULE_TOPIC_BOOST = 1.1;
+/** User entry score when included by default (no keyword match). */
+export const USER_ALWAYS_INCLUDE_SCORE_FRACTION = 0.5;
+// ─── User-facing behavior defaults ─────────────────────────────────────────
+// These are exposed via memory-config.json "behavior" block.
+// All values below are the defaults used when the user has not configured them.
+/** Days since lastAccessed before a standard entry (arch, conv, gotchas, etc.) goes stale. */
+export const DEFAULT_STALE_DAYS_STANDARD = 30;
+/** Days since lastAccessed before a preferences entry goes stale.
+ *  Longer than standard because coding preferences evolve slowly. */
+export const DEFAULT_STALE_DAYS_PREFERENCES = 90;
+/** Maximum stale entries surfaced in a single briefing.
+ *  Keeps the briefing actionable without overwhelming the agent. */
+export const DEFAULT_MAX_STALE_IN_BRIEFING = 5;
+/** Maximum dedup suggestions returned when storing a new entry. */
+export const DEFAULT_MAX_DEDUP_SUGGESTIONS = 3;
+/** Maximum conflict pairs surfaced per query/context response. */
+export const DEFAULT_MAX_CONFLICT_PAIRS = 2;
+/** Maximum related preferences surfaced when storing a non-preference entry. */
+export const DEFAULT_MAX_PREFERENCE_SUGGESTIONS = 3;

package/dist/types.d.ts

@@ -0,0 +1,186 @@
+/** Trust levels for knowledge sources, ordered by reliability */
+export type TrustLevel = 'user' | 'agent-confirmed' | 'agent-inferred';
+/** Parse a raw string into a TrustLevel, returning null for invalid input */
+export declare function parseTrustLevel(raw: string): TrustLevel | null;
+/** Predefined topic scopes for organizing knowledge */
+export type TopicScope = 'user' | 'preferences' | 'architecture' | 'conventions' | 'gotchas' | 'recent-work' | `modules/${string}`;
+/** Parse a raw string into a TopicScope, returning null for invalid input */
+export declare function parseTopicScope(raw: string): TopicScope | null;
+/** Injectable clock for deterministic time in tests */
+export interface Clock {
+    now(): Date;
+    isoNow(): string;
+}
+/** Production clock using real wall time */
+export declare const realClock: Clock;
+/** A single knowledge entry stored in the memory system */
+export interface MemoryEntry {
+    readonly id: string;
+    readonly topic: TopicScope;
+    readonly title: string;
+    readonly content: string;
+    readonly confidence: number;
+    readonly trust: TrustLevel;
+    readonly sources: readonly string[];
+    readonly references?: readonly string[];
+    readonly created: string;
+    readonly lastAccessed: string;
+    readonly gitSha?: string;
+    readonly branch?: string;
+}
+/** In-memory index entry for fast lookups */
+export interface IndexEntry {
+    readonly id: string;
+    readonly topic: TopicScope;
+    readonly title: string;
+    readonly confidence: number;
+    readonly trust: TrustLevel;
+    readonly created: string;
+    readonly lastAccessed: string;
+    readonly file: string;
+    readonly branch?: string;
+}
+/** Detail levels for query responses */
+export type DetailLevel = 'brief' | 'standard' | 'full';
+/** Result of a memory query */
+export interface QueryResult {
+    readonly scope: string;
+    readonly detail: DetailLevel;
+    readonly entries: readonly QueryEntry[];
+    readonly totalEntries: number;
+}
+export interface QueryEntry {
+    readonly id: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly confidence: number;
+    readonly relevanceScore: number;
+    readonly fresh: boolean;
+    readonly references?: readonly string[];
+    readonly content?: string;
+    readonly trust?: TrustLevel;
+    readonly sources?: readonly string[];
+    readonly created?: string;
+    readonly lastAccessed?: string;
+    readonly gitSha?: string;
+    readonly branch?: string;
+}
+/** A related entry surfaced during dedup detection */
+export interface RelatedEntry {
+    readonly id: string;
+    readonly title: string;
+    readonly content: string;
+    readonly confidence: number;
+    readonly trust: TrustLevel;
+}
+/** Result of a memory store operation — discriminated union eliminates impossible states */
+export type StoreResult = {
+    readonly stored: true;
+    readonly id: string;
+    readonly topic: TopicScope;
+    readonly file: string;
+    readonly confidence: number;
+    readonly warning?: string;
+    /** Soft warning when content looks ephemeral — informational, never blocking */
+    readonly ephemeralWarning?: string;
+    readonly relatedEntries?: readonly RelatedEntry[];
+    readonly relevantPreferences?: readonly RelatedEntry[];
+} | {
+    readonly stored: false;
+    readonly topic: TopicScope;
+    readonly warning: string;
+};
+/** Result of a memory correction — discriminated union eliminates impossible states */
+export type CorrectResult = {
+    readonly corrected: true;
+    readonly id: string;
+    readonly action: 'append' | 'replace' | 'delete';
+    readonly newConfidence: number;
+    readonly trust: TrustLevel;
+} | {
+    readonly corrected: false;
+    readonly id: string;
+    readonly error: string;
+};
+/** Memory health statistics */
+export interface MemoryStats {
+    readonly totalEntries: number;
+    readonly corruptFiles: number;
+    readonly byTopic: Record<string, number>;
+    readonly byTrust: Record<TrustLevel, number>;
+    readonly byFreshness: {
+        fresh: number;
+        stale: number;
+        unknown: number;
+    };
+    readonly storageSize: string;
+    readonly storageBudgetBytes: number;
+    readonly memoryPath: string;
+    readonly oldestEntry?: string;
+    readonly newestEntry?: string;
+}
+/** A stale entry surfaced during briefing for agent-driven renewal */
+export interface StaleEntry {
+    readonly id: string;
+    readonly title: string;
+    readonly topic: TopicScope;
+    readonly daysSinceAccess: number;
+}
+/** A pair of entries with high content overlap — potential conflict */
+export interface ConflictPair {
+    readonly a: {
+        readonly id: string;
+        readonly title: string;
+        readonly confidence: number;
+        readonly created: string;
+    };
+    readonly b: {
+        readonly id: string;
+        readonly title: string;
+        readonly confidence: number;
+        readonly created: string;
+    };
+    readonly similarity: number;
+}
+/** Briefing response for session start */
+export interface BriefingResult {
+    readonly briefing: string;
+    readonly entryCount: number;
+    readonly staleEntries: number;
+    readonly staleDetails?: readonly StaleEntry[];
+    readonly suggestion?: string;
+}
+/** Git operations boundary — injected to keep core logic testable and swappable */
+export interface GitService {
+    getCurrentBranch(repoRoot: string): Promise<string>;
+    getHeadSha(repoRoot: string): Promise<string | undefined>;
+}
+/** User-configurable behavior thresholds — exposed via memory-config.json "behavior" block.
+ *  All fields are optional; the system uses the defaults from thresholds.ts when absent. */
+export interface BehaviorConfig {
+    /** Days since lastAccessed before a standard entry (arch, conv, gotchas, etc.) goes stale.
+     *  Lower for fast-moving codebases; higher for stable ones. Default: 30. Range: 1–365. */
+    readonly staleDaysStandard?: number;
+    /** Days since lastAccessed before a preferences entry goes stale.
+     *  Preferences evolve slowly — default 90 keeps them fresh longer. Range: 1–730. */
+    readonly staleDaysPreferences?: number;
+    /** Maximum stale entries shown in a briefing. Default: 5. Range: 1–20. */
+    readonly maxStaleInBriefing?: number;
+    /** Maximum dedup suggestions when storing a new entry. Default: 3. Range: 1–10. */
+    readonly maxDedupSuggestions?: number;
+    /** Maximum conflict pairs shown per query/context response. Default: 2. Range: 1–5. */
+    readonly maxConflictPairs?: number;
+}
+/** Configuration for the memory MCP */
+export interface MemoryConfig {
+    readonly repoRoot: string;
+    readonly memoryPath: string;
+    readonly storageBudgetBytes: number;
+    readonly behavior?: BehaviorConfig;
+    readonly clock?: Clock;
+    readonly git?: GitService;
+}
+/** Default confidence values by trust level */
+export declare const DEFAULT_CONFIDENCE: Record<TrustLevel, number>;
+/** Storage budget: 2MB */
+export declare const DEFAULT_STORAGE_BUDGET_BYTES: number;

package/dist/types.js

@@ -0,0 +1,33 @@
+// Core types for the codebase memory MCP
+//
+// Design principles:
+//   - Make illegal states unrepresentable: discriminated unions over boolean+optional
+//   - Validate at boundaries, trust inside: parse functions at system edges
+//   - Explicit domain types over primitives where meaning matters
+const TRUST_LEVELS = ['user', 'agent-confirmed', 'agent-inferred'];
+/** Parse a raw string into a TrustLevel, returning null for invalid input */
+export function parseTrustLevel(raw) {
+    return TRUST_LEVELS.includes(raw) ? raw : null;
+}
+const FIXED_TOPICS = ['user', 'preferences', 'architecture', 'conventions', 'gotchas', 'recent-work'];
+/** Parse a raw string into a TopicScope, returning null for invalid input */
+export function parseTopicScope(raw) {
+    if (FIXED_TOPICS.includes(raw))
+        return raw;
+    if (raw.startsWith('modules/') && raw.length > 8)
+        return raw;
+    return null;
+}
+/** Production clock using real wall time */
+export const realClock = {
+    now: () => new Date(),
+    isoNow: () => new Date().toISOString(),
+};
+/** Default confidence values by trust level */
+export const DEFAULT_CONFIDENCE = {
+    'user': 1.0,
+    'agent-confirmed': 0.85,
+    'agent-inferred': 0.70,
+};
+/** Storage budget: 2MB */
+export const DEFAULT_STORAGE_BUDGET_BYTES = 2 * 1024 * 1024;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@exaudeus/memory-mcp",
+  "version": "0.1.0",
+  "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "memory-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && cp src/ephemeral-weights.json dist/",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "node --import tsx --test src/__tests__/**/*.test.ts",
+    "prepublishOnly": "npm run build",
+    "semantic-release": "semantic-release"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EtienneBBeaulac/memory-mcp.git"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "codebase-memory",
+    "ai-agent",
+    "firebender"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.2.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@types/node": "^20.0.0",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^24.2.9",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}