squish-memory 1.0.2 → 1.2.0

package/dist/core/compression.d.ts

@@ -0,0 +1,45 @@
+/**
+ * TOON Compression - Token-efficient memory format
+ *
+ * Compact format for memory context using abbreviated notation.
+ * Achieves efficient token usage for context injection.
+ *
+ * Format:
+ * {
+ *   m:[type],      // memory type (1-2 chars)
+ *   c:"...",       // content (truncated)
+ *   t:[],          // tags (array)
+ *   d:123          // days ago
+ * }
+ */
+/**
+ * Compress a memory to TOON format
+ */
+export declare function compressForContext(content: string): string;
+/**
+ * Decompress TOON back to readable format
+ */
+export declare function decompressFromContext(toonString: string): string;
+/**
+ * Estimate compression ratio
+ */
+export declare function estimateCompressionRatio(content: string): number;
+/**
+ * Check if content is JSON
+ */
+export declare function isJson(content: string): boolean;
+/**
+ * Check if content is compressed format
+ */
+export declare function isCompressed(content: string): boolean;
+/**
+ * Count tokens (rough estimate)
+ * Import from context-window.ts - single source of truth
+ */
+import { estimateTokens } from './context/context-window.js';
+export { estimateTokens };
+/**
+ * Truncate to token budget
+ */
+export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
+//# sourceMappingURL=compression.d.ts.map

package/dist/core/compression.js

@@ -0,0 +1,160 @@
+/**
+ * TOON Compression - Token-efficient memory format
+ *
+ * Compact format for memory context using abbreviated notation.
+ * Achieves efficient token usage for context injection.
+ *
+ * Format:
+ * {
+ *   m:[type],      // memory type (1-2 chars)
+ *   c:"...",       // content (truncated)
+ *   t:[],          // tags (array)
+ *   d:123          // days ago
+ * }
+ */
+const MAX_CONTENT_LENGTH = 80; // Max chars per content
+const MAX_TAGS = 3; // Max tags to include
+/**
+ * Compress a memory to TOON format
+ */
+export function compressForContext(content) {
+    // If not JSON or already short, just return
+    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
+        return content;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        // Build compact TOON object
+        const toon = {
+            m: parsed.type?.substring(0, 2) || 'ob', // observation -> ob
+        };
+        // Truncate content
+        if (parsed.content) {
+            const truncated = parsed.content.substring(0, MAX_CONTENT_LENGTH);
+            toon.c = truncated.length < parsed.content.length ? truncated + '..' : truncated;
+        }
+        // Add tags (limited)
+        if (parsed.tags && Array.isArray(parsed.tags)) {
+            toon.t = parsed.tags.slice(0, MAX_TAGS);
+        }
+        // Add days ago if there's a date
+        if (parsed.createdAt) {
+            const days = Math.floor((Date.now() - new Date(parsed.createdAt).getTime()) / (1000 * 60 * 60 * 24));
+            if (days > 0) {
+                toon.d = days;
+            }
+        }
+        return JSON.stringify(toon);
+    }
+    catch {
+        // Not parseable JSON, return truncated content
+        return content.substring(0, MAX_CONTENT_LENGTH);
+    }
+}
+/**
+ * Decompress TOON back to readable format
+ */
+export function decompressFromContext(toonString) {
+    // Check if it's TOON format
+    if (!isCompressed(toonString)) {
+        return toonString;
+    }
+    try {
+        const parsed = JSON.parse(toonString);
+        // If it has TOON markers, expand it
+        if (parsed.m || parsed.c || parsed.t) {
+            const typeMap = {
+                ob: 'observation',
+                su: 'success',
+                f: 'failure',
+                fx: 'fix',
+                i: 'insight',
+            };
+            const type = typeMap[parsed.m] || 'observation';
+            const parts = [`[${type}]`];
+            if (parsed.c) {
+                parts.push(parsed.c);
+            }
+            if (parsed.t && parsed.t.length > 0) {
+                parts.push(`#${parsed.t.join(' #')}`);
+            }
+            if (parsed.d) {
+                parts.push(`(${parsed.d}d ago)`);
+            }
+            return parts.join(' ');
+        }
+        return toonString;
+    }
+    catch {
+        // Not valid TOON, return as-is
+        return toonString;
+    }
+}
+/**
+ * Estimate compression ratio
+ */
+export function estimateCompressionRatio(content) {
+    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
+        return 1.0;
+    }
+    const compressed = compressForContext(content);
+    return compressed.length / content.length;
+}
+/**
+ * Check if content is JSON
+ */
+export function isJson(content) {
+    try {
+        JSON.parse(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if content is compressed format
+ */
+export function isCompressed(content) {
+    if (!content.startsWith('{') || !content.endsWith('}')) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        // Has compressed markers
+        return parsed.m !== undefined || parsed.c !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Count tokens (rough estimate)
+ * Import from context-window.ts - single source of truth
+ */
+import { estimateTokens } from './context/context-window.js';
+export { estimateTokens };
+/**
+ * Truncate to token budget
+ */
+export function truncateToTokenBudget(content, maxTokens) {
+    const tokens = estimateTokens(content);
+    if (tokens <= maxTokens) {
+        return content;
+    }
+    // Binary search for the right length
+    let low = 0;
+    let high = content.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        const estimated = estimateTokens(content.substring(0, mid));
+        if (estimated <= maxTokens) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return content.substring(0, low) + '...';
+}
+//# sourceMappingURL=compression.js.map

package/dist/core/context/agent-context.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Agent Context API - Direct access for agents
+ *
+ * Provides a simple API for agents to get context without CLI calls.
+ * Use this instead of spawning squish CLI processes.
+ *
+ * Usage:
+ *   import { getAgentContext, searchWithPlace } from './core/context/agent-context.js';
+ *
+ *   const context = await getAgentContext(projectPath, { task: "fix bug" });
+ *   const results = await searchWithPlace(projectPath, "error fix", { limit: 5 });
+ */
+export interface AgentContextOptions {
+    /** Current task or action (helps auto-detect relevant place) */
+    task?: string;
+    /** Preferred tier: quick (50 tokens), medium (170), full (500) */
+    tier?: 'quick' | 'medium' | 'full';
+    /** Max memories to return */
+    limit?: number;
+    /** Include place context */
+    includePlaces?: boolean;
+}
+export interface SearchOptions {
+    /** Query string */
+    query: string;
+    /** Optional place filter */
+    place?: string;
+    /** Max results */
+    limit?: number;
+    /** Memory type filter */
+    type?: string;
+}
+/**
+ * Get agent context - the main function I can call directly
+ *
+ * Instead of: squish context --tier medium --has-memories
+ * Use: const ctx = await getAgentContext(projectPath, { task: "fix bug", tier: "medium" })
+ */
+export declare function getAgentContext(projectPath: string, options?: AgentContextOptions): Promise<{
+    ok: boolean;
+    memories: Array<{
+        id: string;
+        type: string;
+        content: string;
+        place?: string;
+        placeType?: string;
+    }>;
+    places: Array<{
+        name: string;
+        type: string;
+        purpose?: string;
+        memories: number;
+        preview?: string[];
+    }>;
+    sessionId?: string;
+    tokens?: number;
+}>;
+/**
+ * Search memories with automatic place detection
+ *
+ * If query contains keywords associated with a place (e.g., "fix" -> Workshop),
+ * it will automatically include that place in results or boost those results.
+ */
+export declare function searchWithPlace(projectPath: string, query: string, options?: SearchOptions): Promise<{
+    ok: boolean;
+    query: string;
+    autoDetectedPlace?: string;
+    count: number;
+    results: Array<{
+        id: string;
+        type: string;
+        content: string;
+        score: number;
+        place?: string;
+        placeType?: string;
+    }>;
+}>;
+/**
+ * Get single memory with place info
+ */
+export declare function getMemoryWithPlace(projectPath: string, memoryId: string): Promise<{
+    ok: boolean;
+    memory?: {
+        id: string;
+        type: string;
+        content: string;
+        tags: string[];
+        createdAt: Date;
+        place?: string;
+        placeType?: string;
+    };
+}>;
+/**
+ * Quick context for session start - lightweight version
+ * Use this when you just need the basics without full context
+ */
+export declare function getQuickContext(projectPath: string, limit?: number): Promise<{
+    ok: boolean;
+    memories: Array<{
+        id: string;
+        type: string;
+        content: string;
+    }>;
+    activePlaces: string[];
+}>;
+//# sourceMappingURL=agent-context.d.ts.map

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

@@ -0,0 +1,274 @@
+/**
+ * Agent Context API - Direct access for agents
+ *
+ * Provides a simple API for agents to get context without CLI calls.
+ * Use this instead of spawning squish CLI processes.
+ *
+ * Usage:
+ *   import { getAgentContext, searchWithPlace } from './core/context/agent-context.js';
+ *
+ *   const context = await getAgentContext(projectPath, { task: "fix bug" });
+ *   const results = await searchWithPlace(projectPath, "error fix", { limit: 5 });
+ */
+import { getRecent, search } from '../memory/memories.js';
+import { getProjectByPath } from '../projects.js';
+import { ensureProject } from '../projects.js';
+import { initializeDefaultPlaces, getProjectPlaces, getMemoryPlace, getPlace, walkPlace } from '../places/index.js';
+import { logger } from '../logger.js';
+/**
+ * Get agent context - the main function I can call directly
+ *
+ * Instead of: squish context --tier medium --has-memories
+ * Use: const ctx = await getAgentContext(projectPath, { task: "fix bug", tier: "medium" })
+ */
+export async function getAgentContext(projectPath, options = {}) {
+    try {
+        await ensureProject(projectPath);
+        const project = await getProjectByPath(projectPath);
+        if (!project) {
+            return { ok: false, memories: [], places: [] };
+        }
+        const tier = options.tier || 'medium';
+        const limit = options.limit || 5;
+        const includePlaces = options.includePlaces !== false;
+        // Get recent memories
+        const memories = await getRecent(projectPath, limit);
+        // Add place info to each memory
+        const memoriesWithPlace = await Promise.all(memories.map(async (m) => {
+            const placeId = await getMemoryPlace(m.id);
+            let placeInfo = {};
+            if (placeId) {
+                const place = await getPlace(placeId);
+                placeInfo = { place: place?.name || null, placeType: place?.placeType || null };
+            }
+            return {
+                id: m.id,
+                type: m.type,
+                content: m.content || m.content,
+                ...placeInfo,
+            };
+        }));
+        // Get places context
+        let places = [];
+        if (includePlaces) {
+            await initializeDefaultPlaces(project.id);
+            const projectPlaces = await getProjectPlaces(project.id);
+            // Filter to populated places only
+            const populatedPlaces = projectPlaces.filter(p => p.memoryCount > 0);
+            if (tier === 'quick') {
+                // Just names
+                places = populatedPlaces.map(p => ({
+                    name: p.name,
+                    type: p.placeType,
+                    memories: p.memoryCount,
+                }));
+            }
+            else if (tier === 'medium') {
+                // Top 3 per place
+                const mediumPlaces = [];
+                for (const p of populatedPlaces.slice(0, 5)) {
+                    const walkResult = await walkPlace(project.id, p.placeType, {
+                        tokenBudget: 170,
+                        maxMemoriesPerPlace: 3,
+                        compressWithCompression: false,
+                    });
+                    mediumPlaces.push({
+                        name: p.name,
+                        type: p.placeType,
+                        purpose: p.purpose,
+                        memories: p.memoryCount,
+                        preview: walkResult?.memories.slice(0, 3).map((m) => m.content?.substring(0, 80)) || [],
+                    });
+                }
+                places = mediumPlaces;
+            }
+            else {
+                // Full
+                places = populatedPlaces.map(p => ({
+                    name: p.name,
+                    type: p.placeType,
+                    purpose: p.purpose,
+                    memories: p.memoryCount,
+                }));
+            }
+        }
+        // Estimate token count
+        const tokens = tier === 'quick' ? 50 : tier === 'medium' ? 170 : 500;
+        return {
+            ok: true,
+            memories: memoriesWithPlace,
+            places,
+            tokens,
+        };
+    }
+    catch (error) {
+        logger.error('[AgentContext] Error getting context:', error);
+        return { ok: false, memories: [], places: [] };
+    }
+}
+/**
+ * Search memories with automatic place detection
+ *
+ * If query contains keywords associated with a place (e.g., "fix" -> Workshop),
+ * it will automatically include that place in results or boost those results.
+ */
+export async function searchWithPlace(projectPath, query, options = { query, limit: 10 }) {
+    try {
+        await ensureProject(projectPath);
+        const project = await getProjectByPath(projectPath);
+        if (!project) {
+            return { ok: false, query, count: 0, results: [] };
+        }
+        // Search
+        const results = await search({
+            query,
+            type: options.type,
+            limit: (options.limit || 10) * 2,
+            project: projectPath,
+        });
+        const limited = results.slice(0, options.limit || 10);
+        // Auto-detect place from query keywords
+        const autoPlace = detectPlaceFromQuery(query);
+        // Add place info to results
+        const resultsWithPlace = await Promise.all(limited.map(async (r) => {
+            const placeId = await getMemoryPlace(r.id);
+            let placeInfo = { place: null, placeType: null };
+            if (placeId) {
+                const place = await getPlace(placeId);
+                placeInfo = {
+                    place: place?.name || null,
+                    placeType: place?.placeType || null,
+                };
+            }
+            return {
+                id: r.id,
+                type: r.type,
+                content: r.content,
+                score: r.similarity ?? 0,
+                ...placeInfo,
+            };
+        }));
+        // Filter by place if specified or auto-detected
+        let filtered = resultsWithPlace;
+        const placeFilter = options.place || autoPlace;
+        if (placeFilter) {
+            filtered = resultsWithPlace.filter((r) => r.placeType === placeFilter);
+        }
+        return {
+            ok: true,
+            query,
+            autoDetectedPlace: autoPlace || undefined,
+            count: filtered.length,
+            results: filtered,
+        };
+    }
+    catch (error) {
+        logger.error('[AgentContext] Error searching:', error);
+        return { ok: false, query, count: 0, results: [] };
+    }
+}
+/**
+ * Detect place type from query keywords
+ *
+ * Maps common terms to place types:
+ * - fix, bug, error, issue -> workshop (fixing stuff)
+ * - design, plan, architecture, api -> library (learning/docs)
+ * - task, todo, manage, organize -> office (work management)
+ * - code, implement, feature -> workshop
+ * - research, learn, study -> library
+ * - experiment, test, try -> lab
+ * - review, archive -> archive
+ */
+function detectPlaceFromQuery(query) {
+    const q = query.toLowerCase();
+    // Map keywords to places
+    const keywords = {
+        workshop: ['fix', 'bug', 'error', 'issue', 'code', 'implement', 'feature', 'refactor', 'debug'],
+        library: ['design', 'plan', 'architecture', 'api', 'learn', 'research', 'study', 'documentation', 'docs'],
+        office: ['task', 'todo', 'manage', 'organize', 'schedule', 'meeting', 'project'],
+        lab: ['test', 'experiment', 'try', 'verify', 'prototype', 'poc'],
+        garden: ['idea', 'brainstorm', 'create', 'design', 'concept'],
+        archive: ['review', 'archive', 'old', 'past', 'historical'],
+    };
+    // Check each place's keywords
+    for (const [placeType, words] of Object.entries(keywords)) {
+        for (const word of words) {
+            if (q.includes(word)) {
+                return placeType;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Get single memory with place info
+ */
+export async function getMemoryWithPlace(projectPath, memoryId) {
+    try {
+        const { getMemory } = await import('../memory/memories.js');
+        const memory = await getMemory(memoryId);
+        if (!memory) {
+            return { ok: false };
+        }
+        // Get place info
+        const placeId = await getMemoryPlace(memoryId);
+        let placeInfo = {};
+        if (placeId) {
+            const place = await getPlace(placeId);
+            placeInfo = {
+                place: place?.name || null,
+                placeType: place?.placeType || null,
+            };
+        }
+        return {
+            ok: true,
+            memory: {
+                id: memory.id,
+                type: memory.type,
+                content: memory.content || '',
+                tags: memory.tags || [],
+                createdAt: memory.createdAt,
+                ...placeInfo,
+            },
+        };
+    }
+    catch (error) {
+        logger.error('[AgentContext] Error getting memory:', error);
+        return { ok: false };
+    }
+}
+/**
+ * Quick context for session start - lightweight version
+ * Use this when you just need the basics without full context
+ */
+export async function getQuickContext(projectPath, limit = 3) {
+    try {
+        await ensureProject(projectPath);
+        const project = await getProjectByPath(projectPath);
+        if (!project) {
+            return { ok: false, memories: [], activePlaces: [] };
+        }
+        // Get recent memories
+        const memories = await getRecent(projectPath, limit);
+        // Get places with memories
+        await initializeDefaultPlaces(project.id);
+        const places = await getProjectPlaces(project.id);
+        const activePlaces = places
+            .filter(p => p.memoryCount > 0)
+            .map(p => p.name);
+        return {
+            ok: true,
+            memories: memories.map((m) => ({
+                id: m.id,
+                type: m.type,
+                content: m.content?.substring(0, 100) || '',
+            })),
+            activePlaces,
+        };
+    }
+    catch (error) {
+        logger.error('[AgentContext] Error getting quick context:', error);
+        return { ok: false, memories: [], activePlaces: [] };
+    }
+}
+//# sourceMappingURL=agent-context.js.map

package/dist/core/{context-paging.d.ts → context/context-paging.d.ts}

@@ -1,14 +1,6 @@
 /**
- * Context Paging Service - Agent-controlled memory loading (Tier 2)
- *
- * Simple memory tracking system that allows agents to:
- * - Load memories into their working set
- * - Evict memories from working set
- * - View what's currently in their working set
- *
- * Note: This does NOT track tokens - Claude is context-aware and manages
- * its own token budget. This just tracks WHAT memories are in the agent's
- * current working set for visibility and management.
+ * Context Paging Service - Agent-controlled memory loading
+ * Allows agents to load/evict memories from working set
  */
 interface LoadedMemory {
     id: string;
@@ -24,7 +16,6 @@ interface LoadedMemory {
 export declare function initializeContextSession(sessionId: string, projectId: string, userId?: string): Promise<void>;
 /**
  * Load a memory into working set
- * Note: Claude manages its own context - this just tracks what you've loaded
  */
 export declare function loadMemoryToContext(sessionId: string, memoryId: string): Promise<{
     success: boolean;
@@ -48,7 +39,6 @@ export declare function viewLoadedMemories(sessionId: string): Promise<{
 }>;
 /**
  * Get context status - what's in your working set and what's available
- * Note: Claude manages its own context/tokens - this just shows WHAT you have loaded
  */
 export declare function getContextStatus(sessionId: string, projectId: string): Promise<{
     success: boolean;