squish-memory 1.0.2 → 1.2.0

package/dist/core/namespaces/index.js

@@ -1,305 +0,0 @@
-/** Namespace Management - Hierarchical folder-like namespaces for memories */
-import { randomUUID } from 'crypto';
-import { eq, and, isNull } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Create a new namespace
- */
-export async function createNamespace(input) {
-    const db = await getDb();
-    if (!db) {
-        throw new Error('Database unavailable');
-    }
-    const schema = await getSchema();
-    const id = randomUUID();
-    // Check if namespace with same name exists under parent
-    const sqliteDb = db;
-    const existing = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(and(eq(schema.namespaces.projectId, input.projectId), eq(schema.namespaces.name, input.name), input.parentId
-        ? eq(schema.namespaces.parentId, input.parentId)
-        : isNull(schema.namespaces.parentId)))
-        .limit(1);
-    if (existing.length > 0) {
-        throw new Error(`Namespace "${input.name}" already exists under ${input.parentId || 'root'}`);
-    }
-    // Build namespace path
-    const path = await buildNamespacePath(input.projectId, input.name, input.parentId ?? null);
-    await sqliteDb.insert(schema.namespaces).values({
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        type: input.type,
-        parentId: input.parentId || null,
-        description: input.description || null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    });
-    logger.info(`[Namespaces] Created namespace: ${path}`);
-    return {
-        id,
-        projectId: input.projectId,
-        name: input.name,
-        type: input.type,
-        parentId: input.parentId || null,
-        description: input.description || null,
-        path,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    };
-}
-/**
- * Build full namespace path from parent
- */
-async function buildNamespacePath(projectId, name, parentId) {
-    if (!parentId) {
-        return name;
-    }
-    const db = await getDb();
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const [parent] = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(eq(schema.namespaces.id, parentId))
-        .limit(1);
-    if (!parent) {
-        return name;
-    }
-    return `${parent.path}/${name}`;
-}
-/**
- * Get a namespace by ID
- */
-export async function getNamespaceById(id) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const [row] = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(eq(schema.namespaces.id, id))
-        .limit(1);
-    if (!row)
-        return null;
-    return {
-        id: row.id,
-        projectId: row.projectId,
-        name: row.name,
-        type: row.type,
-        parentId: row.parentId,
-        description: row.description,
-        path: row.path,
-        createdAt: new Date(row.createdAt),
-        updatedAt: new Date(row.updatedAt),
-    };
-}
-/**
- * Resolve a namespace path to a namespace ID
- * @example resolveNamespacePath('my-project', ['user', 'preferences']) -> namespaceId
- */
-export async function resolveNamespacePath(projectId, path) {
-    if (path.length === 0)
-        return null;
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    let parentId = null;
-    let targetNamespace = null;
-    // Traverse path segments
-    for (const segment of path) {
-        const [result] = await sqliteDb.select()
-            .from(schema.namespaces)
-            .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, segment), parentId
-            ? eq(schema.namespaces.parentId, parentId)
-            : isNull(schema.namespaces.parentId)))
-            .limit(1);
-        if (!result)
-            return null;
-        targetNamespace = result;
-        parentId = result.id;
-    }
-    return targetNamespace?.id || null;
-}
-/**
- * Get namespace tree for a project
- */
-export async function getNamespaceTree(projectId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Get all namespaces for project
-    const all = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(eq(schema.namespaces.projectId, projectId))
-        .orderBy(schema.namespaces.name);
-    // Build tree structure
-    const map = new Map();
-    const roots = [];
-    for (const row of all) {
-        const node = {
-            id: row.id,
-            name: row.name,
-            type: row.type,
-            description: row.description,
-            path: row.path,
-            children: [],
-        };
-        map.set(row.id, node);
-        if (!row.parentId) {
-            roots.push(node);
-        }
-        else {
-            const parent = map.get(row.parentId);
-            if (parent) {
-                parent.children.push(node);
-            }
-        }
-    }
-    return roots;
-}
-/**
- * Get or create default namespaces for a project
- */
-export async function getDefaultNamespaces(projectId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const created = [];
-    const defaults = [
-        { name: 'user', type: 'user', description: 'User-specific memories and preferences' },
-        { name: 'agent', type: 'agent', description: 'Agent-specific knowledge and state' },
-        { name: 'project', type: 'project', description: 'Project-specific decisions and context' },
-    ];
-    const defaultNames = ['user', 'agent', 'project'];
-    // Check all default namespaces at once with IN clause
-    const existing = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, defaultNames[0]), eq(schema.namespaces.type, 'user'), isNull(schema.namespaces.parentId)));
-    if (existing.length > 0) {
-        const ns = await createNamespace({
-            projectId,
-            name: defaultNames[0],
-            type: 'user',
-            parentId: null,
-        });
-        created.push({
-            id: ns.id,
-            projectId: ns.projectId,
-            name: ns.name,
-            type: ns.type,
-            parentId: ns.parentId,
-            description: ns.description,
-            path: ns.path,
-            createdAt: new Date(ns.createdAt),
-            updatedAt: new Date(ns.updatedAt),
-        });
-    }
-    // Check remaining defaults sequentially (agent and project)
-    for (const defName of defaultNames.slice(1)) {
-        const existing = await sqliteDb.select()
-            .from(schema.namespaces)
-            .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, defName), eq(schema.namespaces.type, defName), isNull(schema.namespaces.parentId)))
-            .limit(1);
-        if (existing.length === 0) {
-            const ns = await createNamespace({
-                projectId,
-                name: defName,
-                type: defName === 'agent' ? 'agent' : 'project',
-                parentId: null,
-            });
-            created.push(ns);
-        }
-        else {
-            created.push({
-                id: existing[0].id,
-                projectId: existing[0].projectId,
-                name: existing[0].name,
-                type: existing[0].type,
-                parentId: existing[0].parentId,
-                description: existing[0].description,
-                path: existing[0].path,
-                createdAt: new Date(existing[0].createdAt),
-                updatedAt: new Date(existing[0].updatedAt),
-            });
-        }
-    }
-    logger.info(`[Namespaces] Default namespaces ready for project: ${projectId}`);
-    return created;
-}
-/**
- * List namespaces with optional filtering
- */
-export async function listNamespaces(options = {}) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const conditions = [];
-    if (options.projectId) {
-        conditions.push(eq(schema.namespaces.projectId, options.projectId));
-    }
-    if (options.type) {
-        conditions.push(eq(schema.namespaces.type, options.type));
-    }
-    if (options.parentId !== undefined) {
-        if (options.parentId === null) {
-            conditions.push(isNull(schema.namespaces.parentId));
-        }
-        else {
-            conditions.push(eq(schema.namespaces.parentId, options.parentId));
-        }
-    }
-    const rows = await sqliteDb.select()
-        .from(schema.namespaces)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(schema.namespaces.name);
-    return rows.map((row) => ({
-        id: row.id,
-        projectId: row.projectId,
-        name: row.name,
-        type: row.type,
-        parentId: row.parentId,
-        description: row.description,
-        path: row.path,
-        createdAt: new Date(row.createdAt),
-        updatedAt: new Date(row.updatedAt),
-    }));
-}
-/**
- * Delete a namespace (cascades to child namespaces)
- */
-export async function deleteNamespace(id) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    await sqliteDb.delete(schema.namespaces).where(eq(schema.namespaces.id, id));
-    logger.info(`[Namespaces] Deleted namespace: ${id}`);
-}
-/**
- * Update namespace
- */
-export async function updateNamespace(id, updates) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    await sqliteDb.update(schema.namespaces).set({
-        ...updates,
-        updatedAt: new Date(),
-    }).where(eq(schema.namespaces.id, id));
-    logger.info(`[Namespaces] Updated namespace: ${id}`);
-}
-//# sourceMappingURL=index.js.map

package/dist/core/namespaces/uri-parser.d.ts

@@ -1,31 +0,0 @@
-/** URI Parser for Squish namespace scheme (squish://) */
-export interface SquishURIParsed {
-    type: 'namespace';
-    projectId: string;
-    namespacePath: string[];
-    memoryId?: string;
-}
-/**
- * Parse a squish:// URI into components
- * @example parseSquishURI('squish://my-project/user/preferences') -> { type: 'namespace', projectId: 'my-project', namespacePath: ['user', 'preferences'] }
- */
-export declare function parseSquishURI(uri: string): SquishURIParsed | null;
-/**
- * Build a squish:// URI from components
- * @example buildSquishURI('my-project', ['user', 'preferences']) -> 'squish://my-project/user/preferences'
- */
-export declare function buildSquishURI(projectId: string, path: string[], memoryId?: string): string;
-/**
- * Validate a namespace path (no "..", no empty segments)
- */
-export declare function validateNamespacePath(path: string[]): boolean;
-/**
- * Get parent namespace path
- * @example getParentPath(['user', 'preferences', 'coding']) -> ['user', 'preferences']
- */
-export declare function getParentPath(path: string[]): string[] | null;
-/**
- * Join namespace path segments
- */
-export declare function joinNamespacePath(...segments: (string | string[])[]): string[];
-//# sourceMappingURL=uri-parser.d.ts.map

package/dist/core/namespaces/uri-parser.js

@@ -1,74 +0,0 @@
-/** URI Parser for Squish namespace scheme (squish://) */
-/**
- * Parse a squish:// URI into components
- * @example parseSquishURI('squish://my-project/user/preferences') -> { type: 'namespace', projectId: 'my-project', namespacePath: ['user', 'preferences'] }
- */
-export function parseSquishURI(uri) {
-    if (!uri || typeof uri !== 'string') {
-        return null;
-    }
-    // Match squish://project/path/to/memory
-    const match = uri.match(/^squish:\/\/([^\/]+)\/(.*)$/);
-    if (!match) {
-        return null;
-    }
-    const [, projectId, pathPart] = match;
-    const namespacePath = pathPart ? pathPart.split('/').filter(Boolean) : [];
-    // If path ends with a UUID, it's a memory ID
-    const lastSegment = namespacePath[namespacePath.length - 1];
-    let memoryId;
-    if (lastSegment && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(lastSegment)) {
-        memoryId = lastSegment;
-        namespacePath.pop();
-    }
-    return {
-        type: 'namespace',
-        projectId,
-        namespacePath,
-        memoryId,
-    };
-}
-/**
- * Build a squish:// URI from components
- * @example buildSquishURI('my-project', ['user', 'preferences']) -> 'squish://my-project/user/preferences'
- */
-export function buildSquishURI(projectId, path, memoryId) {
-    if (!projectId) {
-        throw new Error('Project ID is required');
-    }
-    const cleanPath = path.filter(Boolean);
-    const basePath = `squish://${projectId}${cleanPath.length > 0 ? '/' + cleanPath.join('/') : ''}`;
-    return memoryId ? `${basePath}/${memoryId}` : basePath;
-}
-/**
- * Validate a namespace path (no "..", no empty segments)
- */
-export function validateNamespacePath(path) {
-    if (path.length === 0)
-        return true;
-    for (const segment of path) {
-        if (!segment || segment.length === 0) {
-            return false;
-        }
-        if (segment.includes('..')) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Get parent namespace path
- * @example getParentPath(['user', 'preferences', 'coding']) -> ['user', 'preferences']
- */
-export function getParentPath(path) {
-    if (path.length <= 1)
-        return null;
-    return path.slice(0, -1);
-}
-/**
- * Join namespace path segments
- */
-export function joinNamespacePath(...segments) {
-    return segments.flat().filter(Boolean);
-}
-//# sourceMappingURL=uri-parser.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

package/dist/core/search/qmd-search.d.ts

@@ -1,61 +0,0 @@
-/**
- * QMD Hybrid Search Integration
- *
- * Integrates QMD's BM25+vector+rerank pipeline with Squish memories.
- * Provides enhanced search capabilities when QMD is available.
- *
- * QMD Search Pipeline:
- * 1. Query Expansion (LLM generates alternative queries)
- * 2. Parallel BM25 (FTS5) + Vector Search
- * 3. RRF Fusion (Reciprocal Rank Fusion)
- * 4. LLM Re-ranking (yes/no with logprobs)
- * 5. Position-Aware Blending
- *
- * Installation: bun install -g qmd
- * GitHub: https://github.com/tobi/qmd
- */
-import type { SearchInput, SearchResult } from '../memory/memories.js';
-export interface QMDSearchOptions extends SearchInput {
-    useHybrid?: boolean;
-    collection?: string;
-    includeSquishResults?: boolean;
-}
-export interface QMDHybridSearchResult extends SearchResult {
-    qmdScore?: number;
-    source: 'squish' | 'qmd' | 'hybrid';
-}
-/**
- * Search memories using QMD's hybrid search
- *
- * @param options - Search options including query, type, limit, etc.
- * @returns QMD-enhanced search results
- */
-export declare function searchWithQMD(options: QMDSearchOptions): Promise<QMDHybridSearchResult[]>;
-/**
- * Fused search: combine Squish and QMD results
- *
- * Runs both searches in parallel and merges results with deduplication.
- *
- * @param options - Search options
- * @returns Fused search results from both sources
- */
-export declare function fusedSearch(options: QMDSearchOptions): Promise<QMDHybridSearchResult[]>;
-/**
- * Check if QMD is available and configured
- *
- * @returns true if QMD is enabled and available
- */
-export declare function isQMDAvailable(): Promise<boolean>;
-/**
- * Get QMD status and collection info
- *
- * @returns QMD status or null if unavailable
- */
-export declare function getQMDStatus(): Promise<{
-    available: boolean;
-    collections: Array<{
-        name: string;
-        documentCount: number;
-    }>;
-} | null>;
-//# sourceMappingURL=qmd-search.d.ts.map