squish-memory 1.0.1 → 1.1.5

package/dist/core/places/walking.js

@@ -0,0 +1,121 @@
+/**
+ * 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

@@ -7,6 +7,11 @@ export interface ProjectRecord {
 }
 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

@@ -3,9 +3,8 @@ import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { getSchema } from '../db/schema.js';
-import { fromSqliteJson, toSqliteJson } from './memory/serialization.js';
-import { config } from '../config.js';
-import { createDatabaseClient } from './database.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());
@@ -31,26 +30,48 @@ export async function ensureProject(path) {
     const id = randomUUID();
     const name = basename(path) || path;
     const metadata = { source: 'mcp' };
-    if (config.isTeamMode) {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata,
-        });
+    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';
     }
-    else {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata: toSqliteJson(metadata),
-        });
+}
+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 = config.isTeamMode ? row.metadata : fromSqliteJson(row.metadata);
+    const metadata = deserializeMetadata(row.metadata ?? null);
     return {
         id: row.id,
         name: row.name,

package/dist/core/responses.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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

@@ -0,0 +1,122 @@
+/**
+ * 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.js

@@ -1,10 +1,11 @@
 /** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
 import cron from 'node-cron';
 import { selfIterationHandler } from '../session-hooks/self-iteration-job.js';
+import { runLifecycleMaintenance } from '../lifecycle.js';
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { getDb } from '../../db/index.js';
-import { maintenanceJobs, maintenanceJobHistory } from '../../drizzle/schema-sqlite.js';
+import { maintenanceJobs, maintenanceJobHistory } from '../../db/drizzle/schema-sqlite.js';
 import { eq } from 'drizzle-orm';
 const jobHandlers = new Map();
 const activeTasks = new Map();
@@ -14,6 +15,20 @@ export function registerJobHandler(jobName, handler) {
 }
 // Register self-iteration job handler
 registerJobHandler('self_iteration', selfIterationHandler);
+// Decay job handler - runs lifecycle maintenance (decay, tier updates, eviction)
+const decayHandler = async (context) => {
+    const stats = await runLifecycleMaintenance();
+    return {
+        recordsProcessed: stats.decayed + stats.expired + stats.evicted,
+        summary: {
+            decayed: stats.decayed,
+            expired: stats.expired,
+            evicted: stats.evicted,
+            tierChanges: stats.tierChanges,
+        },
+    };
+};
+registerJobHandler('decay_maintenance', decayHandler);
 export async function initializeScheduler() {
     if (!config.cronEnabled) {
         logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
@@ -42,6 +57,13 @@ export async function initializeScheduler() {
 }
 async function ensureDefaultJobs(db) {
     const defaultJobs = [
+        {
+            jobName: 'decay_maintenance',
+            jobType: 'hourly',
+            cronExpression: '0 * * * *', // Run every hour at :00
+            enabled: true,
+            jobConfig: { applyDecay: true, updateTiers: true, evictOld: true },
+        },
         {
             jobName: 'nightly_maintenance',
             jobType: 'nightly',
@@ -65,18 +87,61 @@ async function ensureDefaultJobs(db) {
         },
     ];
     for (const job of defaultJobs) {
-        const existing = await db
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.jobName, job.jobName))
-            .limit(1);
+        let existing;
+        try {
+            existing = await db
+                .select()
+                .from(maintenanceJobs)
+                .where(eq(maintenanceJobs.jobName, job.jobName))
+                .limit(1);
+        }
+        catch (queryError) {
+            logger.error(`[Scheduler] Query failed for job ${job.jobName}:`, queryError.message);
+            // Try raw SQL fallback
+            try {
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    existing = rawDb.prepare('SELECT * FROM maintenance_jobs WHERE job_name = ?').all(job.jobName);
+                }
+            }
+            catch (fallbackError) {
+                logger.error(`[Scheduler] Fallback query also failed:`, fallbackError.message);
+                throw queryError;
+            }
+        }
         if (existing.length === 0) {
-            await db.insert(maintenanceJobs).values({
-                ...job,
-                totalRuns: 0,
-                successCount: 0,
-                failureCount: 0,
-            });
+            try {
+                await db.insert(maintenanceJobs).values({
+                    jobName: job.jobName,
+                    jobType: job.jobType,
+                    cronExpression: job.cronExpression,
+                    enabled: job.enabled,
+                    jobConfig: job.jobConfig,
+                    totalRuns: 0,
+                    successCount: 0,
+                    failureCount: 0,
+                    lastRunAt: null,
+                    nextRunAt: null,
+                    lastRunDuration: null,
+                    lastRunStatus: null,
+                    lastRunError: null,
+                });
+            }
+            catch (insertError) {
+                // Fallback to raw SQL if drizzle insert fails
+                logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    const stmt = rawDb.prepare(`
+            INSERT INTO maintenance_jobs 
+            (id, job_name, job_type, cron_expression, enabled, job_config, 
+             total_runs, success_count, failure_count, last_run_at, next_run_at, 
+             last_run_duration, last_run_status, last_run_error)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `);
+                    stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
+                }
+            }
             logger.info(`[Scheduler] Created default job: ${job.jobName}`);
             // Register self-iteration handler
             if (job.jobName === 'self_iteration') {
@@ -115,7 +180,7 @@ export async function scheduleJob(job) {
             .set({ nextRunAt: nextRun })
             .where(eq(maintenanceJobs.id, job.id));
     }
-    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}, next run: ${nextRun?.toISOString()}`);
+    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}${nextRun ? `, next run: ${nextRun.toISOString()}` : ''}`);
 }
 export async function executeJob(job) {
     const db = await getDb();
@@ -183,13 +248,23 @@ function getNextRunTime(cronExpression) {
     try {
         const now = new Date();
         const parts = cronExpression.split(' ');
-        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+        // Daily jobs: MM HH * * *
+        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*' && parts[1] !== '*') {
             const next = new Date(now);
             next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
             if (next <= now)
                 next.setDate(next.getDate() + 1);
             return next;
         }
+        // Hourly jobs: MM * * * *
+        if (parts[1] === '*' && parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+            const next = new Date(now);
+            next.setMinutes(parseInt(parts[0]), 0, 0);
+            if (next <= now)
+                next.setHours(next.getHours() + 1);
+            return next;
+        }
+        // Weekly jobs: MM HH * * D
         if (parts[4] !== '*') {
             const dayOfWeek = parseInt(parts[4]);
             const next = new Date(now);

package/dist/core/scheduler/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

package/dist/core/scheduler/index.js

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

package/dist/core/scheduler/job-runner.js

@@ -5,7 +5,7 @@ import { runLifecycleMaintenance } from '../lifecycle.js';
 import { pruneWeakAssociations } from '../associations.js';
 import { pruneOldSummaries } from '../summarization.js';
 import { getDb } from '../../db/index.js';
-import { memories, memoryFeedback } from '../../drizzle/schema-sqlite.js';
+import { memories, memoryFeedback } from '../../db/drizzle/schema-sqlite.js';
 import { eq, and, gt, lt } from 'drizzle-orm';
 export async function runNightlyJob(context) {
     const summary = {};