squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/trigger-detector.js

@@ -8,6 +8,15 @@ const EXPLICIT_TRIGGER_PATTERNS = [
     { label: 'save-this', regex: /\bsave\s+this\b/i },
     { label: 'log-this', regex: /\blog\s+this\b/i },
     { label: 'important', regex: /\bimportant\s*:/i },
+    // New: Rationale comment triggers
+    { label: 'NOTE', regex: /NOTE:/i },
+    { label: 'IMPORTANT', regex: /IMPORTANT:/i },
+    { label: 'HACK', regex: /HACK:/i },
+    { label: 'WHY', regex: /WHY:/i },
+    { label: 'TODO', regex: /TODO:/i },
+    { label: 'FIXME', regex: /FIXME:/i },
+    { label: 'XXX', regex: /XXX:/i },
+    { label: 'DEPRECATED', regex: /DEPRECATED:/i },
 ];
 export function detectMemorySignals(content) {
     const text = content.trim();
@@ -20,23 +29,51 @@ export function detectMemorySignals(content) {
             /\b(?:always|never)\b/i.test(text),
         workflowRule: /\b(?:let'?s\s+always\s+do\s+it\s+this\s+way|standard\s+workflow|runbook)\b/i.test(text),
         lesson: /\b(?:failed\s+because|lesson\s+learned|next\s+time|do\s+not\s+repeat|root\s+cause)\b/i.test(text),
+        // New: Rationale patterns from code comments
+        note: /NOTE:/i.test(text),
+        important: /IMPORTANT:/i.test(text),
+        hack: /HACK:/i.test(text),
+        why: /WHY:/i.test(text),
+        todo: /TODO:/i.test(text),
+        fixme: /FIXME:/i.test(text),
     };
     let suggestedType = 'observation';
-    if (implicit.preference)
-        suggestedType = 'preference';
+    // Priority order: decision > preference > lesson > workflowRule > rationale > fact
     if (implicit.decision)
         suggestedType = 'decision';
-    if (implicit.workflowRule || implicit.lesson)
+    else if (implicit.preference)
+        suggestedType = 'preference';
+    else if (implicit.workflowRule || implicit.lesson)
         suggestedType = 'context';
-    if (!implicit.decision && !implicit.preference && /\b(?:is|are|was|were|uses|has|have)\b/i.test(text)) {
+    else if (implicit.todo)
+        suggestedType = 'task';
+    else if (!implicit.decision && !implicit.preference && /\b(?:is|are|was|were|uses|has|have)\b/i.test(text)) {
         suggestedType = 'fact';
     }
-    const priority = explicitTriggers.length > 0 || implicit.correction ? 'high' : 'normal';
+    // Override for specific rationale markers
+    if (implicit.note || implicit.important)
+        suggestedType = 'observation';
+    if (implicit.why)
+        suggestedType = 'context';
+    // Determine confidence based on signal strength
+    let confidence = 'certain';
+    if (implicit.note || implicit.todo)
+        confidence = 'speculative';
+    if (implicit.hack || implicit.fixme)
+        confidence = 'certain'; // Known issues are certain
+    const priority = explicitTriggers.length > 0 ||
+        implicit.correction ||
+        implicit.important ||
+        implicit.hack ||
+        implicit.fixme
+        ? 'high'
+        : 'normal';
     return {
         explicitTriggers,
         implicit,
         suggestedType,
         priority,
+        confidence,
     };
 }
 //# sourceMappingURL=trigger-detector.js.map

package/dist/core/memory/write-gate.js

@@ -3,7 +3,7 @@
  * Validates memories before writing to ensure quality, security, and consistency
  * Integrates secret detection, trigger detection, and content validation
  */
-import { detectSecrets, redactSecrets } from '../secret-detector.js';
+import { detectSecrets, redactSecrets } from '../security/secret-detector.js';
 import { detectMemorySignals } from './trigger-detector.js';
 import { resolveContradictions } from './contradiction-resolver.js';
 import { logger } from '../logger.js';

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

@@ -0,0 +1,14 @@
+/**
+ * Places Module - Spatial memory organization
+ *
+ * Exports:
+ * - places.ts: CRUD operations for places
+ * - rules.ts: Auto-assignment rules engine
+ * - memory-places.ts: Memory-to-place assignments
+ * - walking.ts: Sequential walking through places
+ */
+export * from './places.js';
+export * from './rules.js';
+export * from './memory-places.js';
+export * from './walking.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/places/index.js

@@ -0,0 +1,14 @@
+/**
+ * Places Module - Spatial memory organization
+ *
+ * Exports:
+ * - places.ts: CRUD operations for places
+ * - rules.ts: Auto-assignment rules engine
+ * - memory-places.ts: Memory-to-place assignments
+ * - walking.ts: Sequential walking through places
+ */
+export * from './places.js';
+export * from './rules.js';
+export * from './memory-places.js';
+export * from './walking.js';
+//# sourceMappingURL=index.js.map

package/dist/core/places/memory-places.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Memory-Place Assignments - Assign memories to places
+ *
+ * Handles the assignment of memories to places, both:
+ * - Auto-assignment via rules
+ * - Manual assignment by users
+ */
+import type { PlaceType } from './places.js';
+/**
+ * Assign a memory to a place (auto or manual)
+ */
+export declare function assignMemoryToPlace(params: {
+    memoryId: string;
+    placeId: string;
+    isManual?: boolean;
+    ruleId?: string;
+}): Promise<boolean>;
+/**
+ * Auto-assign a memory based on rules
+ */
+export declare function autoAssignMemory(params: {
+    memoryId: string;
+    projectId: string;
+    toolName?: string;
+    content?: string;
+    tags?: string[];
+    memoryType?: string;
+}): Promise<{
+    assigned: boolean;
+    placeId?: string;
+    placeType?: PlaceType;
+}>;
+/**
+ * Manually assign a memory to a place
+ */
+export declare function manualAssignMemory(params: {
+    memoryId: string;
+    projectId: string;
+    placeType: PlaceType;
+}): Promise<boolean>;
+/**
+ * Get place for a memory
+ */
+export declare function getMemoryPlace(memoryId: string): Promise<string | null>;
+/**
+ * Get memories for a place
+ */
+export declare function getPlaceMemories(placeId: string, limit?: number): Promise<string[]>;
+/**
+ * Remove memory from place
+ */
+export declare function removeMemoryFromPlace(memoryId: string): Promise<boolean>;
+/**
+ * Initialize memory-place for a project (ensures all memories without places get assigned)
+ */
+export declare function initializeProjectPlaces(projectId: string): Promise<{
+    initialized: number;
+    assigned: number;
+}>;
+/**
+ * Auto-archive old memories - move memories > 30 days from active places to Archive
+ * Keeps active places lean and organized
+ */
+export declare function autoArchiveOldMemories(projectId: string, daysOld?: number): Promise<{
+    archived: number;
+    failed: number;
+}>;
+//# sourceMappingURL=memory-places.d.ts.map

package/dist/core/places/memory-places.js

@@ -0,0 +1,261 @@
+/**
+ * Memory-Place Assignments - Assign memories to places
+ *
+ * Handles the assignment of memories to places, both:
+ * - Auto-assignment via rules
+ * - Manual assignment by users
+ */
+import { randomUUID } from 'crypto';
+import { eq, and } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+import { getPlaceByType, updatePlaceMemoryCount } from './places.js';
+import { findMatchingPlace } from './rules.js';
+/**
+ * Assign a memory to a place (auto or manual)
+ */
+export async function assignMemoryToPlace(params) {
+    const db = await getDb();
+    if (!db)
+        return false;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const id = randomUUID();
+    // Check if already assigned
+    const existing = await sqliteDb.select()
+        .from(schema.memoryPlaces)
+        .where(eq(schema.memoryPlaces.memoryId, params.memoryId))
+        .limit(1);
+    if (existing.length > 0) {
+        // Update existing
+        await sqliteDb.update(schema.memoryPlaces)
+            .set({
+            placeId: params.placeId,
+            isManual: params.isManual ? 1 : 0,
+            ruleId: params.ruleId || null,
+        })
+            .where(eq(schema.memoryPlaces.memoryId, params.memoryId));
+    }
+    else {
+        // Insert new
+        await sqliteDb.insert(schema.memoryPlaces).values({
+            id,
+            memoryId: params.memoryId,
+            placeId: params.placeId,
+            isManual: params.isManual ? 1 : 0,
+            ruleId: params.ruleId || null,
+        });
+    }
+    // Update memory's place reference
+    await sqliteDb.update(schema.memories)
+        .set({ placeId: params.placeId })
+        .where(eq(schema.memories.id, params.memoryId));
+    // Update place memory count
+    await updatePlaceMemoryCount(params.placeId);
+    logger.info(`[MemoryPlaces] Assigned memory ${params.memoryId} to place ${params.placeId}`);
+    return true;
+}
+/**
+ * Auto-assign a memory based on rules
+ */
+export async function autoAssignMemory(params) {
+    const { memoryId, projectId, toolName, content, tags, memoryType } = params;
+    // Find matching place via rules
+    const placeType = await findMatchingPlace(projectId, {
+        toolName,
+        content,
+        tags,
+        memoryType,
+    });
+    if (!placeType) {
+        logger.info(`[MemoryPlaces] No matching rule for memory ${memoryId}`);
+        return { assigned: false };
+    }
+    // Get the place
+    const place = await getPlaceByType(projectId, placeType);
+    if (!place) {
+        logger.warn(`[MemoryPlaces] Place not found: ${placeType}`);
+        return { assigned: false };
+    }
+    // Assign
+    const success = await assignMemoryToPlace({
+        memoryId,
+        placeId: place.id,
+        isManual: false,
+    });
+    return {
+        assigned: success,
+        placeId: place.id,
+        placeType,
+    };
+}
+/**
+ * Manually assign a memory to a place
+ */
+export async function manualAssignMemory(params) {
+    const { memoryId, projectId, placeType } = params;
+    // Get the place by type
+    const place = await getPlaceByType(projectId, placeType);
+    if (!place) {
+        logger.warn(`[MemoryPlaces] Place not found: ${placeType}`);
+        return false;
+    }
+    return assignMemoryToPlace({
+        memoryId,
+        placeId: place.id,
+        isManual: true,
+    });
+}
+/**
+ * Get place for a memory
+ */
+export async function getMemoryPlace(memoryId) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const result = await sqliteDb.select()
+        .from(schema.memoryPlaces)
+        .where(eq(schema.memoryPlaces.memoryId, memoryId))
+        .limit(1);
+    return result.length > 0 ? result[0].place_id : null;
+}
+/**
+ * Get memories for a place
+ */
+export async function getPlaceMemories(placeId, limit = 50) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const results = await sqliteDb.select({ memoryId: schema.memoryPlaces.memoryId })
+        .from(schema.memoryPlaces)
+        .where(eq(schema.memoryPlaces.placeId, placeId))
+        .limit(limit);
+    return results.map((r) => r.memoryId);
+}
+/**
+ * Remove memory from place
+ */
+export async function removeMemoryFromPlace(memoryId) {
+    const db = await getDb();
+    if (!db)
+        return false;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Get the place before deleting
+    const existing = await sqliteDb.select()
+        .from(schema.memoryPlaces)
+        .where(eq(schema.memoryPlaces.memoryId, memoryId))
+        .limit(1);
+    if (existing.length > 0) {
+        const oldPlaceId = existing[0].place_id;
+        // Delete assignment
+        await sqliteDb.delete(schema.memoryPlaces)
+            .where(eq(schema.memoryPlaces.memoryId, memoryId));
+        // Clear memory's place reference
+        await sqliteDb.update(schema.memories)
+            .set({ placeId: null })
+            .where(eq(schema.memories.id, memoryId));
+        // Update old place memory count
+        await updatePlaceMemoryCount(oldPlaceId);
+        logger.info(`[MemoryPlaces] Removed memory ${memoryId} from place ${oldPlaceId}`);
+    }
+    return true;
+}
+/**
+ * Initialize memory-place for a project (ensures all memories without places get assigned)
+ */
+export async function initializeProjectPlaces(projectId) {
+    const db = await getDb();
+    if (!db)
+        return { initialized: 0, assigned: 0 };
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Get all memories without a place_id
+    const memoriesWithoutPlace = await sqliteDb.select({ id: schema.memories.id })
+        .from(schema.memories)
+        .where(and(eq(schema.memories.projectId, projectId)));
+    let assigned = 0;
+    for (const mem of memoriesWithoutPlace) {
+        const result = await autoAssignMemory({
+            memoryId: mem.id,
+            projectId,
+            memoryType: 'observation',
+        });
+        if (result.assigned)
+            assigned++;
+    }
+    logger.info(`[MemoryPlaces] Initialized places for project ${projectId}: ${assigned} assigned`);
+    return { initialized: memoriesWithoutPlace.length, assigned };
+}
+/**
+ * Auto-archive old memories - move memories > 30 days from active places to Archive
+ * Keeps active places lean and organized
+ */
+export async function autoArchiveOldMemories(projectId, daysOld = 30) {
+    const db = await getDb();
+    if (!db)
+        return { archived: 0, failed: 0 };
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Get the Archive place
+    const archivePlace = await getPlaceByType(projectId, 'archive');
+    if (!archivePlace) {
+        logger.warn(`[MemoryPlaces] Archive place not found for project ${projectId}`);
+        return { archived: 0, failed: 0 };
+    }
+    // Calculate cutoff date (Unix timestamp for SQLite)
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+    const cutoffTimestamp = Math.floor(cutoffDate.getTime() / 1000);
+    // Get all active place IDs (not archive)
+    const allPlaces = await sqliteDb.select()
+        .from(schema.places)
+        .where(eq(schema.places.projectId, projectId));
+    const activePlaceIds = allPlaces
+        .filter((p) => p.place_type !== 'archive')
+        .map((p) => p.id);
+    if (activePlaceIds.length === 0) {
+        return { archived: 0, failed: 0 };
+    }
+    // Find memories in active places that are older than cutoff
+    // Use raw SQL for complex date comparison
+    const oldMemories = await sqliteDb.select({
+        memoryId: schema.memories.id,
+        placeId: schema.memoryPlaces.placeId,
+        createdAt: schema.memories.createdAt,
+    })
+        .from(schema.memories)
+        .innerJoin(schema.memoryPlaces, eq(schema.memories.id, schema.memoryPlaces.memoryId))
+        .where(and(eq(schema.memories.projectId, projectId)));
+    // Actually filter in JS for simplicity
+    const memoriesToArchive = oldMemories.filter((m) => activePlaceIds.includes(m.placeId) && m.createdAt < cutoffTimestamp);
+    let archived = 0;
+    let failed = 0;
+    for (const mem of memoriesToArchive) {
+        try {
+            // Move to archive place
+            await sqliteDb.update(schema.memoryPlaces)
+                .set({ placeId: archivePlace.id })
+                .where(eq(schema.memoryPlaces.memoryId, mem.memoryId));
+            // Update the old place's memory count
+            await updatePlaceMemoryCount(mem.placeId);
+            archived++;
+        }
+        catch (e) {
+            logger.warn(`[MemoryPlaces] Failed to archive memory ${mem.memoryId}: ${e}`);
+            failed++;
+        }
+    }
+    // Update archive place memory count
+    if (archived > 0) {
+        await updatePlaceMemoryCount(archivePlace.id);
+        logger.info(`[MemoryPlaces] Archived ${archived} old memories to Archive place`);
+    }
+    return { archived, failed };
+}
+//# sourceMappingURL=memory-places.js.map

package/dist/core/places/places.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Places Module - Spatial memory organization
+ *
+ * Provides spatial "places" for memory organization:
+ * - Inbox: New memories, unprocessed
+ * - Ref: Reference, patterns, research
+ * - WIP: Active work, implementations
+ * - Sandbox: Experiments, tests
+ * - Board: Decisions, planning, roadmap
+ * - Sparks: Ideas, future concepts
+ * - Archive: Completed, historical
+ */
+export type PlaceType = 'inbox' | 'ref' | 'wip' | 'sandbox' | 'board' | 'sparks' | 'archive';
+export interface Place {
+    id: string;
+    projectId: string;
+    name: string;
+    placeType: PlaceType;
+    parentId: string | null;
+    sortOrder: number;
+    positionX: number;
+    positionY: number;
+    description: string | null;
+    purpose: string | null;
+    memoryCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PlaceCreateInput {
+    projectId: string;
+    name: string;
+    placeType: PlaceType;
+    parentId?: string | null;
+    sortOrder?: number;
+    description?: string;
+    purpose?: string;
+}
+export interface PlaceUpdateInput {
+    name?: string;
+    description?: string;
+    purpose?: string;
+    sortOrder?: number;
+    positionX?: number;
+    positionY?: number;
+}
+export declare const DEFAULT_PLACES: Omit<PlaceCreateInput, 'projectId'>[];
+/**
+ * Create a new place
+ */
+export declare function createPlace(input: PlaceCreateInput): Promise<Place>;
+/**
+ * Get a place by ID
+ */
+export declare function getPlace(id: string): Promise<Place | null>;
+/**
+ * Get places for a project, ordered by sort_order
+ */
+export declare function getProjectPlaces(projectId: string): Promise<Place[]>;
+/**
+ * Get place by type for a project
+ */
+export declare function getPlaceByType(projectId: string, placeType: PlaceType): Promise<Place | null>;
+/**
+ * Update a place
+ */
+export declare function updatePlace(id: string, input: PlaceUpdateInput): Promise<Place | null>;
+/**
+ * Delete a place
+ */
+export declare function deletePlace(id: string): Promise<boolean>;
+/**
+ * Initialize default 7 places for a project
+ */
+export declare function initializeDefaultPlaces(projectId: string): Promise<Place[]>;
+/**
+ * Get place by loci index
+ */
+export declare function getPlaceByLociIndex(projectId: string, sortOrder: number): Promise<Place | null>;
+/**
+ * Update memory count for a place
+ */
+export declare function updatePlaceMemoryCount(placeId: string): Promise<void>;
+/**
+ * Sync all place memory counts - recalculate counts for all places in a project
+ * Useful for fixing counts after bulk operations or data recovery
+ */
+export declare function syncAllPlaceMemoryCounts(projectId: string): Promise<void>;
+//# sourceMappingURL=places.d.ts.map