squish-memory 1.1.5 → 1.2.1

package/dist/core/places/walking.js

@@ -1,121 +0,0 @@
-/**
- * Walking Interface - Sequential memory retrieval through places
- *
- * Implements Method of Loci walking through memory places:
- * - Walk single place to get memories in order
- * - Walk all places for full tour
- * - Token budget handling with TOON compression
- */
-import { getProjectPlaces } from './places.js';
-import { getPlaceMemories } from './memory-places.js';
-import { getMemory } from '../memory/memories.js';
-import { compressForContext } from '../toon.js';
-import { logger } from '../logger.js';
-/**
- * Walk through a single place
- */
-export async function walkPlace(projectId, placeType, options = {}) {
-    const { tokenBudget = 170, maxMemoriesPerPlace = 10, includePurpose = true, compressWithToon = false } = options;
-    // Get the place
-    const places = await getProjectPlaces(projectId);
-    const place = places.find(p => p.placeType === placeType);
-    if (!place) {
-        logger.warn(`[Walking] Place not found: ${placeType}`);
-        return null;
-    }
-    // Get memory IDs for this place
-    const memoryIds = await getPlaceMemories(place.id, maxMemoriesPerPlace);
-    // Get full memories
-    const memories = [];
-    let totalTokens = 0;
-    for (const memoryId of memoryIds) {
-        const memory = await getMemory(memoryId);
-        if (!memory)
-            continue;
-        let content = memory.content || '';
-        // Compress with TOON if requested
-        if (compressWithToon && content) {
-            content = compressForContext(content);
-        }
-        const tokenEstimate = Math.ceil(content.length / 4); // rough token estimate
-        if (totalTokens + tokenEstimate > tokenBudget) {
-            // Would exceed budget - stop adding
-            break;
-        }
-        memories.push({
-            id: memory.id,
-            content,
-            type: memory.type,
-            tags: memory.tags || [],
-            createdAt: memory.createdAt || '',
-        });
-        totalTokens += tokenEstimate;
-    }
-    return {
-        place,
-        memories,
-        totalTokens,
-        truncated: memories.length < memoryIds.length,
-    };
-}
-/**
- * Walk through all places in loci order
- */
-export async function walkAllPlaces(projectId, options = {}) {
-    const places = await getProjectPlaces(projectId);
-    const results = [];
-    for (const place of places) {
-        const walkResult = await walkPlace(projectId, place.placeType, options);
-        if (walkResult && walkResult.memories.length > 0) {
-            results.push(walkResult);
-        }
-    }
-    logger.info(`[Walking] Walked ${results.length} places for project ${projectId}`);
-    return results;
-}
-/**
- * Quick tour - just place names and purposes (minimal tokens)
- */
-export async function quickTour(projectId) {
-    const places = await getProjectPlaces(projectId);
-    return {
-        places: places.map(p => ({
-            name: p.name,
-            purpose: p.purpose || '',
-            memoryCount: p.memoryCount,
-        })),
-        totalMemories: places.reduce((sum, p) => sum + p.memoryCount, 0),
-    };
-}
-/**
- * Get context summary for a place (for injection)
- */
-export async function getPlaceContext(projectId, placeType, maxTokens = 50) {
-    const walkResult = await walkPlace(projectId, placeType, {
-        tokenBudget: maxTokens,
-        compressWithToon: true,
-    });
-    if (!walkResult || walkResult.memories.length === 0) {
-        return '';
-    }
-    const lines = walkResult.memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content.substring(0, 100)}`);
-    return `## ${walkResult.place.name}\n${lines.join('\n')}`;
-}
-/**
- * Full context for session start (all places)
- */
-export async function getFullWalkingContext(projectId, maxTokens = 170) {
-    const results = await walkAllPlaces(projectId, {
-        tokenBudget: Math.floor(maxTokens / 7), // Distribute across 7 places
-        compressWithToon: true,
-    });
-    if (results.length === 0) {
-        return 'No memories yet. Start building your spatial memory!';
-    }
-    const sections = results.map(r => {
-        const lines = r.memories.slice(0, 3).map((m, i) => `  ${i + 1}. ${m.content.substring(0, 60)}...`).join('\n');
-        return `## ${r.place.name}\n${lines}`;
-    });
-    return sections.join('\n\n');
-}
-//# sourceMappingURL=walking.js.map

package/dist/core/projects.d.ts

@@ -1,17 +0,0 @@
-export interface ProjectRecord {
-    id: string;
-    name: string;
-    path: string;
-    description?: string | null;
-    metadata?: Record<string, unknown> | null;
-}
-export declare function getProjectByPath(path: string): Promise<ProjectRecord | null>;
-export declare function ensureProject(path?: string): Promise<ProjectRecord | null>;
-export declare class ProjectNotFoundError extends Error {
-    constructor(path: string);
-}
-export declare function requireProject(path: string): Promise<ProjectRecord>;
-export declare function getOrCreateProject(path?: string): Promise<ProjectRecord | null>;
-export declare function getAllProjects(): Promise<ProjectRecord[]>;
-export declare function getProjectById(id: string): Promise<ProjectRecord | null>;
-//# sourceMappingURL=projects.d.ts.map

package/dist/core/projects.js

@@ -1,108 +0,0 @@
-import { basename } from 'path';
-import { randomUUID } from 'crypto';
-import { eq } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { serializeMetadata, deserializeMetadata } from './memory/serialization.js';
-import { createDatabaseClient } from './storage/database.js';
-export async function getProjectByPath(path) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const rows = await db.select().from(schema.projects).where(eq(schema.projects.path, path)).limit(1);
-        const row = rows[0];
-        if (!row)
-            return null;
-        return normalizeProject(row);
-    }
-    catch (error) {
-        throw error;
-    }
-}
-export async function ensureProject(path) {
-    if (!path)
-        return null;
-    const existing = await getProjectByPath(path);
-    if (existing)
-        return existing;
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const id = randomUUID();
-    const name = basename(path) || path;
-    const metadata = { source: 'mcp' };
-    await db.insert(schema.projects).values({
-        id,
-        name,
-        path,
-        metadata: serializeMetadata(metadata),
-    });
-    return { id, name, path, metadata };
-}
-export class ProjectNotFoundError extends Error {
-    constructor(path) {
-        super(`Project not found: ${path}`);
-        this.name = 'ProjectNotFoundError';
-    }
-}
-export async function requireProject(path) {
-    const project = await getProjectByPath(path);
-    if (!project) {
-        throw new ProjectNotFoundError(path);
-    }
-    return project;
-}
-export async function getOrCreateProject(path) {
-    if (!path)
-        return null;
-    const existing = await getProjectByPath(path);
-    if (existing)
-        return existing;
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const id = randomUUID();
-    const name = basename(path) || path;
-    const metadata = { source: 'mcp' };
-    await db.insert(schema.projects).values({
-        id,
-        name,
-        path,
-        metadata: serializeMetadata(metadata),
-    });
-    return { id, name, path, metadata };
-}
-function normalizeProject(row) {
-    const metadata = deserializeMetadata(row.metadata ?? null);
-    return {
-        id: row.id,
-        name: row.name,
-        path: row.path,
-        description: row.description ?? null,
-        metadata,
-    };
-}
-export async function getAllProjects() {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const rows = await db.select().from(schema.projects);
-        return rows.map(normalizeProject);
-    }
-    catch (error) {
-        throw error;
-    }
-}
-export async function getProjectById(id) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const rows = await db.select().from(schema.projects).where(eq(schema.projects.id, id)).limit(1);
-        const row = rows[0];
-        if (!row)
-            return null;
-        return normalizeProject(row);
-    }
-    catch (error) {
-        throw error;
-    }
-}
-//# sourceMappingURL=projects.js.map

package/dist/core/redis.d.ts

@@ -1,11 +0,0 @@
-import { RedisClientType } from 'redis';
-export declare function getRedisClient(): Promise<RedisClientType>;
-export declare function closeRedisConnection(): Promise<void>;
-export declare function cacheGet<T>(key: string): Promise<T | null>;
-export declare function cacheSet<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-export declare function cacheDelete(key: string): Promise<void>;
-export declare function cacheClear(pattern: string): Promise<void>;
-export declare function publish(channel: string, message: unknown): Promise<void>;
-export declare function subscribe(channel: string, callback: (message: unknown) => void): Promise<void>;
-export declare function checkRedisHealth(): Promise<boolean>;
-//# sourceMappingURL=redis.d.ts.map

package/dist/core/redis.js

@@ -1,69 +0,0 @@
-import { createClient } from 'redis';
-import { performRedisPublish } from './utils/memory-operations.js';
-import { logger } from './logger.js';
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-let client = null;
-export async function getRedisClient() {
-    if (client && client.isOpen) {
-        return client;
-    }
-    client = createClient({ url: REDIS_URL });
-    client.on('error', (err) => {
-        logger.error('Redis client error', err);
-    });
-    client.on('connect', () => {
-        logger.info('Redis connected');
-    });
-    await client.connect();
-    return client;
-}
-export async function closeRedisConnection() {
-    if (client && client.isOpen) {
-        await client.quit();
-        client = null;
-    }
-}
-// Cache helpers with TTL
-export async function cacheGet(key) {
-    const redis = await getRedisClient();
-    const value = await redis.get(key);
-    return value ? JSON.parse(value) : null;
-}
-export async function cacheSet(key, value, ttlSeconds = 300) {
-    const redis = await getRedisClient();
-    await redis.setEx(key, ttlSeconds, JSON.stringify(value));
-}
-export async function cacheDelete(key) {
-    const redis = await getRedisClient();
-    await redis.del(key);
-}
-export async function cacheClear(pattern) {
-    const redis = await getRedisClient();
-    const keys = await redis.keys(pattern);
-    if (keys.length > 0) {
-        await redis.del(keys);
-    }
-}
-// Pub/Sub for real-time sync
-export async function publish(channel, message) {
-    await performRedisPublish(getRedisClient, channel, message);
-}
-export async function subscribe(channel, callback) {
-    const subscriber = (await getRedisClient()).duplicate();
-    await subscriber.connect();
-    await subscriber.subscribe(channel, (message) => {
-        callback(JSON.parse(message));
-    });
-}
-// Check Redis health
-export async function checkRedisHealth() {
-    try {
-        const redis = await getRedisClient();
-        const pong = await redis.ping();
-        return pong === 'PONG';
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=redis.js.map

package/dist/core/responses.d.ts

@@ -1,96 +0,0 @@
-/**
- * ResponseFormatter - Unified response formatting for all Squish output contexts
- * @module core/responses
- */
-export type ResponseStatus = 'ok' | 'error';
-export interface BaseResponse<T = unknown> {
-    status: ResponseStatus;
-    message?: string;
-    data?: T;
-    error?: string;
-    timestamp?: string;
-}
-export interface PaginatedResponse<T> extends BaseResponse<T[]> {
-    count: number;
-    total?: number;
-    page?: number;
-    limit?: number;
-}
-/**
- * Format options for web responses
- */
-export interface WebFormatOptions {
-    statusCode?: number;
-    pagination?: {
-        total: number;
-        page: number;
-        limit: number;
-    };
-}
-/**
- * Unified response formatter for all Squish output contexts
- */
-export declare class ResponseFormatter {
-    /**
-     * Generate ISO timestamp
-     */
-    private static getTimestamp;
-    /**
-     * Build base response with timestamp
-     */
-    private static buildBase;
-    /**
-     * Format response for CLI output (pretty-printed JSON)
-     */
-    static cli<T>(data: T, message?: string): string;
-    /**
-     * Format error for CLI and exit process
-     */
-    static cliError(error: Error): never;
-    /**
-     * Format successful response for Web API
-     */
-    static web<T>(data: T, message?: string, options?: WebFormatOptions): {
-        status: number;
-        body: BaseResponse<T>;
-    };
-    /**
-     * Format error response for Web API
-     */
-    static webError(error: Error, options?: {
-        statusCode?: number;
-        log?: boolean;
-    }): {
-        status: number;
-        body: BaseResponse;
-    };
-    /**
-     * Format response for MCP tools
-     */
-    static mcp<T>(data: T, message?: string): {
-        content: Array<{
-            type: string;
-            text: string;
-        }>;
-    };
-    /**
-     * Format error for MCP tools (throws McpError)
-     */
-    static mcpError(error: Error, context?: string): never;
-    /**
-     * Format response for algorithm handlers
-     */
-    static algorithm<T>(data: T, message: string, options?: {
-        ok?: boolean;
-        error?: string;
-    }): BaseResponse<T>;
-    /**
-     * Convenience method for success responses
-     */
-    static success<T>(data: T, message?: string): BaseResponse<T>;
-    /**
-     * Convenience method for failure responses
-     */
-    static failure(message: string, error?: Error | string): BaseResponse;
-}
-//# sourceMappingURL=responses.d.ts.map

package/dist/core/responses.js

@@ -1,122 +0,0 @@
-/**
- * ResponseFormatter - Unified response formatting for all Squish output contexts
- * @module core/responses
- */
-/**
- * Unified response formatter for all Squish output contexts
- */
-export class ResponseFormatter {
-    /**
-     * Generate ISO timestamp
-     */
-    static getTimestamp() {
-        return new Date().toISOString();
-    }
-    /**
-     * Build base response with timestamp
-     */
-    static buildBase(status, message, data, error) {
-        return {
-            status,
-            message,
-            data,
-            error,
-            timestamp: this.getTimestamp(),
-        };
-    }
-    // CLI Formatters
-    /**
-     * Format response for CLI output (pretty-printed JSON)
-     */
-    static cli(data, message) {
-        const response = this.buildBase(data instanceof Error ? 'error' : 'ok', message, data);
-        return JSON.stringify(response, null, 2);
-    }
-    /**
-     * Format error for CLI and exit process
-     */
-    static cliError(error) {
-        const response = this.buildBase('error', error.message, undefined, error.message);
-        console.error(JSON.stringify(response, null, 2));
-        process.exit(1);
-    }
-    // Web API Formatters
-    /**
-     * Format successful response for Web API
-     */
-    static web(data, message, options) {
-        const body = this.buildBase('ok', message, data);
-        // Add pagination metadata if provided
-        if (options?.pagination) {
-            body.count = options.pagination.total;
-            body.total = options.pagination.total;
-            body.page = options.pagination.page;
-            body.limit = options.pagination.limit;
-        }
-        return {
-            status: options?.statusCode ?? 200,
-            body,
-        };
-    }
-    /**
-     * Format error response for Web API
-     */
-    static webError(error, options) {
-        const statusCode = options?.statusCode ?? 500;
-        const body = this.buildBase('error', error.message, undefined, error.message);
-        if (options?.log !== false) {
-            console.error(`[Web API Error ${statusCode}]:`, error.message);
-        }
-        return { status: statusCode, body };
-    }
-    // MCP Formatters
-    /**
-     * Format response for MCP tools
-     */
-    static mcp(data, message) {
-        const response = this.buildBase('ok', message, data);
-        return {
-            content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
-        };
-    }
-    /**
-     * Format error for MCP tools (throws McpError)
-     */
-    static mcpError(error, context) {
-        const message = context ? `${context}: ${error.message}` : error.message;
-        const response = this.buildBase('error', message, undefined, message);
-        // Import McpError dynamically to avoid requiring @modelcontextprotocol/sdk in non-MCP contexts
-        try {
-            const { McpError, ErrorCode } = require('@modelcontextprotocol/sdk/types.js');
-            throw new McpError(ErrorCode.InternalError, JSON.stringify(response));
-        }
-        catch (e) {
-            // If McpError is not available, throw a standard error with MCP-formatted message
-            const mcpError = new Error(JSON.stringify(response));
-            mcpError.name = 'McpError';
-            throw mcpError;
-        }
-    }
-    // Algorithm Handler Formatters
-    /**
-     * Format response for algorithm handlers
-     */
-    static algorithm(data, message, options) {
-        const isOk = options?.ok !== false;
-        return this.buildBase(isOk ? 'ok' : 'error', message, isOk ? data : undefined, options?.error);
-    }
-    /**
-     * Convenience method for success responses
-     */
-    static success(data, message) {
-        return this.buildBase('ok', message, data);
-    }
-    /**
-     * Convenience method for failure responses
-     */
-    static failure(message, error) {
-        const errorMessage = error instanceof Error ? error.message : error;
-        return this.buildBase('error', message, undefined, errorMessage);
-    }
-}
-//# sourceMappingURL=responses.js.map

package/dist/core/scheduler/cron-scheduler.d.ts

@@ -1,32 +0,0 @@
-/** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
-export type JobType = 'nightly' | 'weekly' | 'hourly';
-export type JobStatus = 'success' | 'failed' | 'skipped';
-export interface ScheduledJob {
-    id: string;
-    jobName: string;
-    jobType: JobType;
-    cronExpression: string;
-    enabled: boolean;
-    lastRunAt: Date | null;
-    nextRunAt: Date | null;
-    jobConfig: Record<string, unknown>;
-}
-export interface JobExecutionContext {
-    jobId: string;
-    jobName: string;
-    jobType: JobType;
-    config: Record<string, unknown>;
-    startedAt: Date;
-}
-export type JobHandler = (context: JobExecutionContext) => Promise<{
-    recordsProcessed: number;
-    summary: Record<string, unknown>;
-}>;
-export declare function registerJobHandler(jobName: string, handler: JobHandler): void;
-export declare function initializeScheduler(): Promise<void>;
-export declare function scheduleJob(job: ScheduledJob): Promise<void>;
-export declare function executeJob(job: ScheduledJob): Promise<void>;
-export declare function getScheduledJobs(): Promise<ScheduledJob[]>;
-export declare function getOverdueJobs(): Promise<ScheduledJob[]>;
-export declare function stopAllJobs(): void;
-//# sourceMappingURL=cron-scheduler.d.ts.map