squish-memory 1.2.0 → 1.2.1

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

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

@@ -1,274 +0,0 @@
-/**
- * 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/context-paging.d.ts

@@ -1,80 +0,0 @@
-/**
- * Context Paging Service - Agent-controlled memory loading
- * Allows agents to load/evict memories from working set
- */
-interface LoadedMemory {
-    id: string;
-    type: string;
-    content: string;
-    contentPreview: string;
-    loadedAt: Date;
-}
-/**
- * Initialize or get a context session
- * Simplified - just tracks what's loaded, not tokens (Claude manages its own context)
- */
-export declare function initializeContextSession(sessionId: string, projectId: string, userId?: string): Promise<void>;
-/**
- * Load a memory into working set
- */
-export declare function loadMemoryToContext(sessionId: string, memoryId: string): Promise<{
-    success: boolean;
-    message?: string;
-    memory?: LoadedMemory;
-}>;
-/**
- * Evict a memory from working set
- */
-export declare function evictMemoryFromContext(sessionId: string, memoryId: string): Promise<{
-    success: boolean;
-    message?: string;
-}>;
-/**
- * View all memories in working set
- */
-export declare function viewLoadedMemories(sessionId: string): Promise<{
-    success: boolean;
-    memories: LoadedMemory[];
-    count: number;
-}>;
-/**
- * Get context status - what's in your working set and what's available
- */
-export declare function getContextStatus(sessionId: string, projectId: string): Promise<{
-    success: boolean;
-    coreMemory: {
-        sizeBytes: number;
-        maxBytes: number;
-        usagePercent: number;
-    };
-    workingSet: {
-        loadedCount: number;
-        loadedMemories: Array<{
-            id: string;
-            type: string;
-            contentLength: number;
-        }>;
-    };
-    available: {
-        totalMemories: number;
-        totalObservations: number;
-    };
-    note: string;
-}>;
-/**
- * Clear all loaded memories from working set
- */
-export declare function clearLoadedMemories(sessionId: string): Promise<{
-    success: boolean;
-    message?: string;
-}>;
-/**
- * Get all memories currently marked as in-context for a session
- */
-export declare function getInContextMemories(sessionId: string): Promise<LoadedMemory[]>;
-/**
- * Get out-of-context (archived) memories for a project
- */
-export declare function getOutOfContextMemories(projectId: string, limit?: number): Promise<LoadedMemory[]>;
-export {};
-//# sourceMappingURL=context-paging.d.ts.map