squish-memory 1.1.5 → 1.2.0

package/dist/core/commands/remember.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Remember Command - Unified memory write
+ *
+ * Single implementation for both CLI and MCP.
+ */
+export interface CommandResult {
+    ok: boolean;
+    [key: string]: any;
+}
+export interface RememberOptions {
+    content: string;
+    project?: string;
+    tags?: string;
+    tier?: 'hot' | 'cold';
+    type?: string;
+    learningType?: 'success' | 'failure' | 'fix' | 'insight';
+    confidence?: string;
+    source?: 'cli' | 'voice' | 'chat' | 'document';
+    route?: 'auto' | 'memory' | 'learning' | 'note';
+    pin?: boolean;
+    unpin?: boolean;
+}
+export declare function executeRemember(options: RememberOptions): Promise<CommandResult>;
+//# sourceMappingURL=remember.d.ts.map

package/dist/core/commands/remember.js

@@ -0,0 +1,144 @@
+/**
+ * Remember Command - Unified memory write
+ *
+ * Single implementation for both CLI and MCP.
+ */
+import { rememberMemory, findSimilarMemories } from '../memory/memories.js';
+import { createLearning } from '../ingestion/learnings.js';
+import { pinMemory, unpinMemory } from '../security/governance.js';
+import { detectMemorySignals } from '../memory/trigger-detector.js';
+export async function executeRemember(options) {
+    const { content, project, tags, tier, type, learningType, source, route, pin, unpin } = options;
+    const signals = detectMemorySignals(content);
+    let routing = "memory";
+    let inferredType = type || signals.suggestedType;
+    let routingReason = "";
+    // Check for learning patterns if auto mode
+    if (route === "auto" || !route) {
+        const hasLessonPattern = /(\bfailed\s+because\b|\blesson\s+learned\b|\bnext\s+time\b|\broot\s+cause\b|\bsuccess\b.*\bbecause\b|\bi\s+learned\b|\binsight\b)/i.test(content);
+        const hasLearningType = /(\bsuccess\b|\bfailure\b|\bfix\b|\binsight\b)/i.test(content);
+        const hasHackPattern = /(\bHACK\b|\bworkaround\b|\btemporary\s+fix\b)/i.test(content);
+        const hasFixmePattern = /(\bFIXME\b|\bXXX\b|\bbug\b.*\bfix\b)/i.test(content);
+        if (hasLessonPattern || hasLearningType || hasHackPattern || hasFixmePattern) {
+            routing = "learning";
+            if (hasHackPattern || hasFixmePattern) {
+                routingReason = "Detected code pattern (HACK/FIXME)";
+            }
+            else {
+                routingReason = "Detected learning pattern in content";
+            }
+        }
+        else if (signals.suggestedType === 'task') {
+            routing = "memory";
+            routingReason = "Detected TODO pattern";
+        }
+        else if (signals.suggestedType === 'observation' && /\b(note|note\s+that|log|remember)\b/i.test(content)) {
+            routing = "note";
+            routingReason = "Detected note pattern";
+        }
+        else {
+            routing = "memory";
+            routingReason = `Detected as ${inferredType}`;
+        }
+    }
+    else if (route === "learning") {
+        routing = "learning";
+        routingReason = "Override: forced to learning";
+    }
+    else if (route === "note") {
+        routing = "note";
+        routingReason = "Override: forced to note";
+    }
+    else {
+        routing = "memory";
+        routingReason = "Override: forced to memory";
+    }
+    let result;
+    const parsedTags = tags ? tags.split(',').map((t) => t.trim()) : [];
+    const parsedTier = tier === "cold" ? "cold" : "hot";
+    if (routing === "learning") {
+        let parsedLearningType = "insight";
+        if (learningType) {
+            parsedLearningType = learningType;
+        }
+        else {
+            if (/(\bsuccess\b|\bworked\b|\bfinished\b)/i.test(content))
+                parsedLearningType = "success";
+            else if (/(\bfailed\b|\berror\b|\bbroke\b)/i.test(content))
+                parsedLearningType = "failure";
+            else if (/(\bfix\b|\b workaround\b|\bsolved\b)/i.test(content))
+                parsedLearningType = "fix";
+        }
+        const learning = await createLearning({
+            type: parsedLearningType,
+            content,
+            project,
+            autoLink: true
+        });
+        result = { id: learning.id, type: "learning", learningType: parsedLearningType, content };
+    }
+    else {
+        // Check for similar memories to avoid duplicates (deduplication)
+        const similarMemories = await findSimilarMemories(content, 0.85, 3);
+        const memory = await rememberMemory({
+            content,
+            type: inferredType,
+            tags: parsedTags,
+            project,
+            tier: parsedTier,
+            source: source || 'cli'
+        });
+        // If found similar memories, create association instead of duplicate
+        if (similarMemories.length > 0) {
+            const { createAssociation } = await import('../associations.js');
+            for (const similar of similarMemories) {
+                await createAssociation(memory.id, similar.id, 'duplicate', similar.similarity ?? 0.85);
+            }
+            memory.similarTo = similarMemories.map(s => s.id);
+        }
+        if (pin) {
+            await pinMemory(memory.id);
+        }
+        else if (unpin) {
+            await unpinMemory(memory.id);
+        }
+        result = { id: memory.id, type: "memory", memoryType: inferredType, tier: parsedTier, content, pinned: pin };
+        // Auto-update knowledge graph (fire-and-forget, don't fail remember on graph error)
+        const { addMemoryToGraph } = await import('../graph/graph-builder.js');
+        const graphResult = await addMemoryToGraph(memory.id).catch((e) => {
+            console.warn('[Graph] Auto-update failed:', e.message);
+            return null;
+        });
+        if (graphResult) {
+            result.graph = { entities: graphResult.entitiesCreated, relations: graphResult.relationsCreated };
+        }
+        // Auto-assign to place (fire-and-forget)
+        const { autoAssignMemory } = await import('../places/memory-places.js');
+        const projectId = memory.projectId || project;
+        const placeResult = await autoAssignMemory({
+            memoryId: memory.id,
+            projectId: projectId,
+            content: content,
+            tags: parsedTags,
+            memoryType: inferredType
+        }).catch((e) => {
+            console.warn('[Places] Auto-assign failed:', e.message);
+            return null;
+        });
+        if (placeResult?.assigned && placeResult.placeId) {
+            result.place = { id: placeResult.placeId, type: placeResult.placeType ?? 'inbox' };
+        }
+    }
+    return {
+        ok: true,
+        id: result.id,
+        routing,
+        type: routing === "learning" ? result.learningType : result.memoryType,
+        tier: routing === "memory" ? parsedTier : 'N/A',
+        priority: signals.priority,
+        confidence: signals.confidence,
+        pinned: result.pinned,
+        reason: routingReason
+    };
+}
+//# sourceMappingURL=remember.js.map

package/dist/core/{toon.d.ts → compression.d.ts}

@@ -29,15 +29,17 @@ export declare function estimateCompressionRatio(content: string): number;
  */
 export declare function isJson(content: string): boolean;
 /**
- * Check if content is TOON format
+ * Check if content is compressed format
  */
-export declare function isToon(content: string): boolean;
+export declare function isCompressed(content: string): boolean;
 /**
  * Count tokens (rough estimate)
+ * Import from context-window.ts - single source of truth
  */
-export declare function estimateTokens(text: string): number;
+import { estimateTokens } from './context/context-window.js';
+export { estimateTokens };
 /**
  * Truncate to token budget
  */
 export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
-//# sourceMappingURL=toon.d.ts.map
+//# sourceMappingURL=compression.d.ts.map

package/dist/core/{toon.js → compression.js}

@@ -56,7 +56,7 @@ export function compressForContext(content) {
  */
 export function decompressFromContext(toonString) {
     // Check if it's TOON format
-    if (!isToon(toonString)) {
+    if (!isCompressed(toonString)) {
         return toonString;
     }
     try {
@@ -113,15 +113,15 @@ export function isJson(content) {
     }
 }
 /**
- * Check if content is TOON format
+ * Check if content is compressed format
  */
-export function isToon(content) {
+export function isCompressed(content) {
     if (!content.startsWith('{') || !content.endsWith('}')) {
         return false;
     }
     try {
         const parsed = JSON.parse(content);
-        // Has TOON markers
+        // Has compressed markers
         return parsed.m !== undefined || parsed.c !== undefined;
     }
     catch {
@@ -130,10 +130,10 @@ export function isToon(content) {
 }
 /**
  * Count tokens (rough estimate)
+ * Import from context-window.ts - single source of truth
  */
-export function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
+import { estimateTokens } from './context/context-window.js';
+export { estimateTokens };
 /**
  * Truncate to token budget
  */
@@ -157,4 +157,4 @@ export function truncateToTokenBudget(content, maxTokens) {
     }
     return content.substring(0, low) + '...';
 }
-//# sourceMappingURL=toon.js.map
+//# sourceMappingURL=compression.js.map

package/dist/core/context/agent-context.js

@@ -70,7 +70,7 @@ export async function getAgentContext(projectPath, options = {}) {
                     const walkResult = await walkPlace(project.id, p.placeType, {
                         tokenBudget: 170,
                         maxMemoriesPerPlace: 3,
-                        compressWithToon: false,
+                        compressWithCompression: false,
                     });
                     mediumPlaces.push({
                         name: p.name,

package/dist/core/embeddings/embeddings.d.ts

@@ -0,0 +1,29 @@
+import { MultimodalInput } from './google-multimodal.js';
+export type EmbeddingProvider = 'local' | 'openai' | 'ollama' | 'lmstudio' | 'transformers' | 'google' | 'none' | 'auto';
+export declare function getEmbedding(input: string | MultimodalInput): Promise<number[] | null>;
+/**
+ * Get embeddings for multiple inputs in parallel batches
+ * Processes inputs in batches to respect rate limits while parallelizing
+ */
+export declare function getBatchEmbeddings(inputs: string[], batchSize?: number): Promise<Array<number[] | null>>;
+/**
+ * Clear the embedding cache
+ */
+export declare function clearEmbeddingCache(): void;
+/**
+ * Get embedding cache statistics
+ */
+export declare function getEmbeddingCacheStats(): {
+    size: number;
+    maxSize: number;
+};
+/**
+ * Check health of all configured embedding providers
+ * Returns availability and latency for each provider
+ */
+export declare function checkEmbeddingProviderHealth(): Promise<Map<string, {
+    available: boolean;
+    latencyMs?: number;
+    error?: string;
+}>>;
+//# sourceMappingURL=embeddings.d.ts.map