squish-memory 1.0.2 → 1.1.5

package/dist/api/web/web.d.ts

@@ -1,4 +0,0 @@
-declare const app: import("express-serve-static-core").Express;
-export declare function startWebServer(): void;
-export default app;
-//# sourceMappingURL=web.d.ts.map

package/dist/commands/mcp-server.js

@@ -1,393 +0,0 @@
-#!/usr/bin/env node
-// CRITICAL: Redirect console.log to stderr to prevent JSON-RPC stream corruption
-// MCP stdio requires stdout to contain ONLY valid JSON-RPC messages
-console.log = console.error;
-console.info = console.error;
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express from "express";
-import { z } from "zod";
-import { config } from "../config.js";
-import { hybridSearch } from "../core/memory/hybrid-retrieval.js";
-import { rememberMemory, searchMemories, getMemoryById } from "../core/memory/memories.js";
-import { getEmbedding } from "../core/embeddings.js";
-import { getQMDClient } from "../core/embeddings/qmd-client.js";
-import { createAssociation, getRelatedMemories } from "../core/associations.js";
-import { createObservation, getObservationsForProject } from "../core/observations.js";
-import { getProjectByPath, getAllProjects } from "../core/projects.js";
-import { getMemoryStats } from "../core/memory/stats.js";
-import { getDb } from "../db/index.js";
-import { getSchema } from "../db/schema.js";
-import { eq } from "drizzle-orm";
-const SERVER_NAME = "squish-memory";
-const SERVER_VERSION = "1.0.2";
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let mode = "stdio";
-    let port = config.mcpServerPort || 8767;
-    let health = false;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--http" || args[i] === "-h") {
-            mode = "http";
-        }
-        else if (args[i] === "--stdio" || args[i] === "-s") {
-            mode = "stdio";
-        }
-        else if (args[i] === "--port" || args[i] === "-p") {
-            port = parseInt(args[i + 1], 10) || 8767;
-            i++;
-        }
-        else if (args[i] === "--health" || args[i] === "--check") {
-            health = true;
-        }
-    }
-    if (process.env.SQUISH_MCP_MODE === "http") {
-        mode = "http";
-    }
-    return { mode, port, health };
-}
-function safeRegisterTool(server, name, definition, handler) {
-    try {
-        server.registerTool(name, definition, handler);
-        console.error(`[MCP] Registered tool: ${name}`);
-        return true;
-    }
-    catch (error) {
-        console.error(`[MCP] Failed to register tool ${name}:`, error);
-        return false;
-    }
-}
-function createSquishServer() {
-    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
-    let toolCount = 0;
-    console.error(`[MCP] Starting tool registration...`);
-    if (safeRegisterTool(server, "squish_search", {
-        description: "Hybrid search across QMD, SQLite DB, and embeddings with graph expansion",
-        inputSchema: {
-            query: z.string().describe("Search query"),
-            limit: z.number().min(1).max(100).default(5).describe("Maximum results"),
-            project: z.string().optional().describe("Project path filter"),
-            mode: z.enum(["hybrid", "qmd", "db", "semantic"]).default("hybrid").describe("Search mode")
-        }
-    }, async ({ query, limit = 5, project, mode = "hybrid" }) => {
-        const results = await hybridSearch({
-            query,
-            limit,
-            project,
-            candidateLimit: 50,
-            resultLimit: limit
-        });
-        const formatted = results.map((r, i) => `${i + 1}. [${r.type || "memory"}] ${r.content?.substring(0, 200)}... (score: ${r.hybridScore?.toFixed(2)})`).join("\n");
-        return { content: [{ type: "text", text: `Found ${results.length} memories:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_remember", {
-        description: "Store a new memory in Squish with automatic embedding",
-        inputSchema: {
-            content: z.string().describe("Memory content to store"),
-            type: z.enum(["observation", "fact", "decision", "context", "preference"]).default("observation").describe("Memory type"),
-            tags: z.array(z.string()).optional().describe("Optional tags"),
-            project: z.string().optional().describe("Project path")
-        }
-    }, async ({ content, type = "observation", tags = [], project }) => {
-        const memory = await rememberMemory({ content, type: type, tags, project });
-        return { content: [{ type: "text", text: `Memory stored: ${memory.id}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_recall", {
-        description: "Retrieve a specific memory by ID",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to retrieve")
-        }
-    }, async ({ memoryId }) => {
-        const memory = await getMemoryById(memoryId);
-        if (!memory) {
-            return { content: [{ type: "text", text: `Memory not found: ${memoryId}` }], isError: true };
-        }
-        return { content: [{ type: "text", text: JSON.stringify(memory, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_forget", {
-        description: "Delete a memory by ID",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to delete")
-        }
-    }, async ({ memoryId }) => {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Cast to any to handle Drizzle ORM union type issue
-        const sqliteDb = db;
-        const result = await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
-        return { content: [{ type: "text", text: `Memory deleted: ${memoryId}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_update", {
-        description: "Update an existing memory",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to update"),
-            content: z.string().optional().describe("New content"),
-            tags: z.array(z.string()).optional().describe("New tags"),
-            type: z.enum(["observation", "fact", "decision", "context", "preference"]).optional().describe("New type")
-        }
-    }, async ({ memoryId, content, tags, type }) => {
-        const db = await getDb();
-        const schema = await getSchema();
-        const updates = {};
-        if (content)
-            updates.content = content;
-        if (tags)
-            updates.tags = config.isTeamMode ? tags : JSON.stringify(tags);
-        if (type)
-            updates.type = type;
-        if (Object.keys(updates).length === 0) {
-            return { content: [{ type: "text", text: "No updates provided" }], isError: true };
-        }
-        // Cast to any to handle Drizzle ORM union type issue
-        const sqliteDb2 = db;
-        await sqliteDb2.update(schema.memories).set(updates).where(eq(schema.memories.id, memoryId));
-        return { content: [{ type: "text", text: `Memory updated: ${memoryId}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_qmd_search", {
-        description: "Search markdown files using QMD (BM25 + vector)",
-        inputSchema: {
-            query: z.string().describe("Search query"),
-            collection: z.string().optional().describe("QMD collection name"),
-            limit: z.number().min(1).max(100).default(10).describe("Maximum results")
-        }
-    }, async ({ query, collection, limit = 10 }) => {
-        const client = await getQMDClient();
-        const available = await client.isAvailable();
-        if (!available) {
-            return { content: [{ type: "text", text: "QMD not available. Install with: bun install -g qmd" }], isError: true };
-        }
-        const results = await client.search({ query, collection, limit });
-        const formatted = results.map((r, i) => `${i + 1}. ${r.path || r.file} (score: ${r.score?.toFixed(2)})\n   ${r.content?.substring(0, 150)}...`).join("\n\n");
-        return { content: [{ type: "text", text: `QMD found ${results.length} results:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_associate", {
-        description: "Create an association between two memories in the graph",
-        inputSchema: {
-            fromMemoryId: z.string().uuid().describe("Source memory ID"),
-            toMemoryId: z.string().uuid().describe("Target memory ID"),
-            type: z.enum(["relates_to", "supersedes", "contradicts", "supports", "duplicate", "merged"]).describe("Association type"),
-            weight: z.number().min(0).max(1).default(0.5).describe("Association strength (0-1)")
-        }
-    }, async ({ fromMemoryId, toMemoryId, type, weight = 0.5 }) => {
-        await createAssociation(fromMemoryId, toMemoryId, type, weight);
-        return { content: [{ type: "text", text: `Association created: ${fromMemoryId} -> ${toMemoryId} (${type})` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_related", {
-        description: "Get related memories via graph traversal",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to find relations for"),
-            depth: z.number().min(1).max(5).default(2).describe("Graph traversal depth"),
-            minWeight: z.number().min(0).max(1).default(0.3).describe("Minimum association weight")
-        }
-    }, async ({ memoryId, depth = 2, minWeight = 0.3 }) => {
-        const related = await getRelatedMemories(memoryId, depth * 5);
-        const filtered = related.filter((r) => r.weight >= minWeight);
-        const formatted = filtered.map((r, i) => `${i + 1}. [${r.type || "memory"}] ${r.content?.substring(0, 100)}... (weight: ${r.weight?.toFixed(2)})`).join("\n");
-        return { content: [{ type: "text", text: `Found ${related.length} related memories:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_context", {
-        description: "Get project context with relevant memories",
-        inputSchema: {
-            project: z.string().describe("Project path"),
-            limit: z.number().min(1).max(50).default(10).describe("Maximum memories to return")
-        }
-    }, async ({ project, limit = 10 }) => {
-        const projectRecord = await getProjectByPath(project);
-        if (!projectRecord) {
-            return { content: [{ type: "text", text: `Project not found: ${project}` }], isError: true };
-        }
-        const recentMemories = await searchMemories({ query: "", project, limit });
-        const observations = await getObservationsForProject(project, 5);
-        const context = {
-            project: projectRecord,
-            recentMemories: recentMemories.slice(0, limit),
-            recentObservations: observations
-        };
-        return { content: [{ type: "text", text: JSON.stringify(context, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_observe", {
-        description: "Store an observation about tool usage, patterns, or insights",
-        inputSchema: {
-            type: z.enum(["tool_use", "file_change", "error", "pattern", "insight"]).describe("Observation type"),
-            action: z.string().describe("Action performed"),
-            summary: z.string().describe("Summary of observation"),
-            target: z.string().optional().describe("Target file or resource"),
-            project: z.string().optional().describe("Project path")
-        }
-    }, async ({ type, action, summary, target, project }) => {
-        const observation = await createObservation({ type, action, summary, target, project });
-        return { content: [{ type: "text", text: `Observation stored: ${observation.id}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_embed", {
-        description: "Generate embeddings for text using configured provider",
-        inputSchema: {
-            text: z.string().describe("Text to embed")
-        }
-    }, async ({ text }) => {
-        const embedding = await getEmbedding(text);
-        if (!embedding) {
-            return { content: [{ type: "text", text: "Failed to generate embedding" }], isError: true };
-        }
-        return { content: [{ type: "text", text: JSON.stringify({ dimensions: embedding.length, preview: embedding.slice(0, 5) }, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_health", {
-        description: "Check Squish system health status",
-        inputSchema: {}
-    }, async () => {
-        const qmdClient = await getQMDClient();
-        const qmdAvailable = await qmdClient.isAvailable();
-        return { content: [{ type: "text", text: JSON.stringify({
-                        status: "ok",
-                        version: SERVER_VERSION,
-                        mode: config.isManagedMode ? "managed" : "local",
-                        embeddings: config.embeddingsProvider,
-                        qmd: qmdAvailable ? "available" : "unavailable",
-                        timestamp: new Date().toISOString()
-                    }, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_stats", {
-        description: "Get memory statistics for a project",
-        inputSchema: {
-            project: z.string().optional().describe("Project path (defaults to current)")
-        }
-    }, async ({ project }) => {
-        const stats = await getMemoryStats(project || process.cwd());
-        return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_projects", {
-        description: "List all registered projects",
-        inputSchema: {}
-    }, async () => {
-        const projects = await getAllProjects();
-        const formatted = projects.map((p, i) => `${i + 1}. ${p.name}\n   Path: ${p.path}\n   ID: ${p.id}`).join("\n\n");
-        return { content: [{ type: "text", text: `Found ${projects.length} projects:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    console.error(`[MCP] Tool registration complete. Registered ${toolCount} tools.`);
-    return { server, toolCount };
-}
-async function runStdio(server, toolCount) {
-    console.error(`[MCP] Starting in STDIO mode...`);
-    const transport = new StdioServerTransport();
-    transport.onclose = () => {
-        console.error(`[MCP] STDIO transport closed`);
-    };
-    await server.connect(transport);
-    console.error(`[MCP] Connected via stdio. ${toolCount} tools available.`);
-    // Keep process alive - wait for stdin to close or process signals
-    await new Promise((resolve) => {
-        process.stdin.on('close', () => {
-            console.error(`[MCP] STDIO stdin closed, shutting down`);
-            resolve();
-        });
-        process.on('SIGINT', () => {
-            console.error(`[MCP] Received SIGINT, shutting down`);
-            resolve();
-        });
-        process.on('SIGTERM', () => {
-            console.error(`[MCP] Received SIGTERM, shutting down`);
-            resolve();
-        });
-    });
-}
-async function runHttp(server, port) {
-    console.error(`[MCP] Starting in HTTP mode on port ${port}...`);
-    const app = express();
-    app.use(express.json());
-    const transports = new Map();
-    app.get("/health", (req, res) => {
-        res.json({ status: "ok", server: SERVER_NAME, version: SERVER_VERSION });
-    });
-    app.get("/sse", async (req, res) => {
-        const transport = new SSEServerTransport("/message", res);
-        const sessionId = Math.random().toString(36).substring(7);
-        transports.set(sessionId, transport);
-        console.error(`[MCP] SSE connection established: ${sessionId}`);
-        await server.connect(transport);
-        req.on("close", () => {
-            console.error(`[MCP] SSE connection closed: ${sessionId}`);
-            transports.delete(sessionId);
-        });
-    });
-    app.post("/message", async (req, res) => {
-        const sessionId = req.headers["mcp-session-id"] || "default";
-        const transport = transports.get(sessionId);
-        if (!transport) {
-            res.status(400).json({ error: "No active session" });
-            return;
-        }
-        try {
-            await transport.handlePostMessage(req, res);
-        }
-        catch (error) {
-            console.error(`[MCP] Error handling message:`, error);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    await new Promise((resolve) => app.listen(port, () => {
-        console.error(`[MCP] HTTP server listening on port ${port}`);
-        console.error(`[MCP] SSE endpoint: http://localhost:${port}/sse`);
-        console.error(`[MCP] Health: http://localhost:${port}/health`);
-        resolve();
-    }));
-}
-async function runHealthCheck() {
-    console.error(`[MCP] Running health check...`);
-    try {
-        const { server, toolCount } = createSquishServer();
-        console.error(`[MCP] Health check passed. Server initialized with ${toolCount} tools.`);
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(`[MCP] Health check failed:`, error);
-        process.exit(1);
-    }
-}
-async function main() {
-    try {
-        console.error(`[${SERVER_NAME}] v${SERVER_VERSION} initializing...`);
-        console.error(`[${SERVER_NAME}] Mode: ${config.isManagedMode ? "managed" : "local"}`);
-        console.error(`[${SERVER_NAME}] Embeddings: ${config.embeddingsProvider}`);
-        const { mode, port, health } = parseArgs();
-        if (health) {
-            await runHealthCheck();
-            return;
-        }
-        const { server, toolCount } = createSquishServer();
-        const shutdown = async () => {
-            console.error(`[${SERVER_NAME}] Shutting down...`);
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-        if (mode === "stdio") {
-            await runStdio(server, toolCount);
-        }
-        else {
-            await runHttp(server, port);
-        }
-    }
-    catch (error) {
-        console.error(`[${SERVER_NAME}] Fatal error:`, error);
-        process.exit(1);
-    }
-}
-main().catch((error) => {
-    console.error(`[${SERVER_NAME}] Fatal error:`, error);
-    process.exit(1);
-});
-//# sourceMappingURL=mcp-server.js.map

package/dist/core/context.js

@@ -1,24 +0,0 @@
-import { getProjectByPath } from './projects.js';
-import { getRecentMemories } from './memory/memories.js';
-import { getObservationsForProject } from './observations.js';
-import { getEntitiesForProject } from './search/entities.js';
-export async function getProjectContext(input) {
-    const project = await getProjectByPath(input.project);
-    const include = input.include ?? ['memories', 'observations'];
-    const limit = Math.min(Math.max(input.limit ?? 10, 1), 100);
-    if (!project) {
-        return { project: null, memories: [], observations: [] };
-    }
-    const result = { project };
-    if (include.includes('memories')) {
-        result.memories = await getRecentMemories(project.path, limit);
-    }
-    if (include.includes('observations')) {
-        result.observations = await getObservationsForProject(project.path, limit);
-    }
-    if (include.includes('entities')) {
-        result.entities = await getEntitiesForProject(project.path, limit);
-    }
-    return result;
-}
-//# sourceMappingURL=context.js.map

package/dist/core/governance.js

@@ -1,64 +0,0 @@
-/**
- * Memory Governance
- * Implements protection, pinning, and immutability rules
- */
-import { eq } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { config } from '../config.js';
-import { performMemoryOperation } from './utils/memory-operations.js';
-import { logger } from './logger.js';
-/**
- * Mark a memory as protected (cannot be evicted)
- */
-export async function protectMemory(memoryId, reason) {
-    await performMemoryOperation(memoryId, {
-        name: 'protecting memory',
-        updates: {
-            isProtected: true,
-            metadata: { protectionReason: reason, protectedAt: new Date().toISOString() },
-        },
-    });
-}
-/**
- * Pin a memory for automatic injection into context
- */
-export async function pinMemory(memoryId) {
-    await performMemoryOperation(memoryId, {
-        name: 'pinning memory',
-        updates: {
-            isPinned: true,
-            metadata: { pinnedAt: new Date().toISOString() },
-        },
-    });
-}
-/**
- * Unpin a memory
- */
-export async function unpinMemory(memoryId) {
-    await performMemoryOperation(memoryId, {
-        name: 'unpinning memory',
-        updates: { isPinned: false },
-    });
-}
-/**
- * Get all pinned memories for auto-injection into context
- */
-export async function getPinnedMemories() {
-    if (!config.governanceEnabled)
-        return [];
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.isPinned, true))
-            .limit(50);
-    }
-    catch (error) {
-        logger.error('Error retrieving pinned memories', error);
-        return [];
-    }
-}
-//# sourceMappingURL=governance.js.map

package/dist/core/observations.d.ts

@@ -1,26 +0,0 @@
-export type ObservationType = 'tool_use' | 'file_change' | 'error' | 'pattern' | 'insight';
-export interface ObservationInput {
-    type: ObservationType;
-    action: string;
-    target?: string;
-    summary: string;
-    details?: Record<string, unknown>;
-    session?: string;
-    project?: string;
-}
-export interface ObservationRecord {
-    id: string;
-    projectId?: string | null;
-    conversationId?: string | null;
-    type: ObservationType;
-    action: string;
-    target?: string | null;
-    summary: string;
-    details?: Record<string, unknown> | null;
-    createdAt?: string | null;
-}
-export declare function createObservation(input: ObservationInput): Promise<ObservationRecord>;
-export declare function getObservationsForProject(projectPath: string, limit: number): Promise<ObservationRecord[]>;
-export declare function getRecentObservations(projectPath: string, limit?: number): Promise<ObservationRecord[]>;
-export declare function getObservationById(observationId: string): Promise<ObservationRecord | null>;
-//# sourceMappingURL=observations.d.ts.map

package/dist/core/observations.js

@@ -1,110 +0,0 @@
-import { randomUUID } from 'crypto';
-import { desc, eq } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { config } from '../config.js';
-import { getEmbedding } from './embeddings.js';
-import { ensureProject, getProjectByPath } from './projects.js';
-import { fromSqliteJson, toSqliteJson } from './memory/serialization.js';
-import { createDatabaseClient } from './database.js';
-import { normalizeTimestamp, prepareEmbedding } from './utils.js';
-import { logger } from './logger.js';
-export async function createObservation(input) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const project = await ensureProject(input.project);
-    const embedding = await getEmbedding(input.summary);
-    const id = randomUUID();
-    const baseValues = {
-        id,
-        projectId: project?.id ?? null,
-        type: input.type,
-        action: input.action,
-        target: input.target ?? null,
-        summary: input.summary,
-    };
-    const embeddingValues = prepareEmbedding(embedding);
-    const detailsValue = config.isTeamMode ? input.details ?? null : toSqliteJson(input.details ?? null);
-    await db.insert(schema.observations).values({
-        ...baseValues,
-        details: detailsValue,
-        ...embeddingValues,
-        createdAt: new Date(),
-    });
-    return {
-        id,
-        projectId: project?.id ?? null,
-        conversationId: null,
-        type: input.type,
-        action: input.action,
-        target: input.target ?? null,
-        summary: input.summary,
-        details: input.details ?? null,
-    };
-}
-export async function getObservationsForProject(projectPath, limit) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const project = await getProjectByPath(projectPath);
-        if (!project)
-            return [];
-        const rows = await db.select().from(schema.observations)
-            .where(eq(schema.observations.projectId, project.id))
-            .orderBy(desc(schema.observations.createdAt))
-            .limit(limit);
-        return rows.map((row) => normalizeObservation(row));
-    }
-    catch (error) {
-        throw error;
-    }
-}
-export async function getRecentObservations(projectPath, limit = 10) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const project = await getProjectByPath(projectPath);
-        if (!project)
-            return [];
-        const rows = await db.select().from(schema.observations)
-            .where(eq(schema.observations.projectId, project.id))
-            .orderBy(desc(schema.observations.createdAt))
-            .limit(limit);
-        return rows.map((row) => normalizeObservation(row));
-    }
-    catch (error) {
-        logger.error('Error getting recent observations', error);
-        throw error;
-    }
-}
-export async function getObservationById(observationId) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const rows = await db.select().from(schema.observations)
-            .where(eq(schema.observations.id, observationId))
-            .limit(1);
-        if (rows.length === 0)
-            return null;
-        return normalizeObservation(rows[0]);
-    }
-    catch (error) {
-        logger.error('Error getting observation', error);
-        throw error;
-    }
-}
-function normalizeObservation(row) {
-    const details = config.isTeamMode ? row.details : fromSqliteJson(row.details ?? null);
-    return {
-        id: row.id,
-        projectId: row.projectId ?? row.project_id ?? null,
-        conversationId: row.conversationId ?? row.conversation_id ?? null,
-        type: row.type,
-        action: row.action,
-        target: row.target ?? null,
-        summary: row.summary,
-        details,
-        createdAt: normalizeTimestamp(row.createdAt ?? row.created_at),
-    };
-}
-//# sourceMappingURL=observations.js.map

package/dist/core/requirements.d.ts

@@ -1,20 +0,0 @@
-export interface MemoryCriteria {
-    tag?: string;
-    type?: string;
-    types?: string[];
-    sector?: string;
-    minAge?: number;
-    maxAge?: number;
-    minConfidence?: number;
-    minRelevance?: number;
-    projectId?: string;
-    agentId?: string;
-    visibilityScope?: string;
-}
-export declare function requireMemory(criteria: MemoryCriteria): Promise<any>;
-export declare function assertMemoryPresent(memoryId: string): Promise<void>;
-export declare function assertMemoryNotPresent(criteria: MemoryCriteria): Promise<void>;
-export declare function requireMemories(criteria: MemoryCriteria, minCount?: number): Promise<any[]>;
-export declare function requireHighConfidenceMemory(criteria: MemoryCriteria, minConfidence?: number): Promise<any>;
-export declare function requireRecentMemory(criteria: MemoryCriteria, maxAgeDays?: number): Promise<any>;
-//# sourceMappingURL=requirements.d.ts.map

package/dist/core/requirements.js

@@ -1,35 +0,0 @@
-// Deterministic Memory Requirements
-import { eq } from 'drizzle-orm';
-import { getSchema } from '../db/schema.js';
-import { buildMemoryFilters, buildMemoryFiltersPartial } from './utils/filter-builder.js';
-import { executeMemoryAssertion } from './utils/query-operations.js';
-export async function requireMemory(criteria) {
-    const schema = await getSchema();
-    const filters = buildMemoryFilters(criteria, schema);
-    const memories = await executeMemoryAssertion(criteria, filters, 1, 'memory requirement', 'Required memory not found');
-    return memories[0];
-}
-export async function assertMemoryPresent(memoryId) {
-    const criteria = { memoryId };
-    const schema = await getSchema();
-    const filters = [eq(schema.memories.id, memoryId)];
-    await executeMemoryAssertion(criteria, filters, 1, 'asserting memory presence', 'Required memory is not present: ' + memoryId);
-}
-export async function assertMemoryNotPresent(criteria) {
-    const schema = await getSchema();
-    const filters = buildMemoryFiltersPartial(criteria, schema);
-    await executeMemoryAssertion(criteria, filters, 0, 'checking memory non-presence', 'Memory should not exist but was found');
-}
-export async function requireMemories(criteria, minCount = 1) {
-    const schema = await getSchema();
-    const filters = buildMemoryFilters(criteria, schema);
-    return executeMemoryAssertion(criteria, filters, minCount, 'checking memory requirements', `Required ${minCount} memories but found fewer`);
-}
-export async function requireHighConfidenceMemory(criteria, minConfidence = 80) {
-    return requireMemory({ ...criteria, minConfidence });
-}
-export async function requireRecentMemory(criteria, maxAgeDays = 7) {
-    const maxAge = maxAgeDays * 24 * 60 * 60 * 1000;
-    return requireMemory({ ...criteria, maxAge });
-}
-//# sourceMappingURL=requirements.js.map