squish-memory 1.0.2 → 1.1.5

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,
+                        compressWithToon: 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;

package/dist/core/{context-paging.js → context/context-paging.js}

@@ -1,28 +1,17 @@
 /**
- * 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
  */
 import { eq, and } from 'drizzle-orm';
 import { sql } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { createDatabaseClient } from './database.js';
-import { getMemoryById } from './memory/memories.js';
+import { getMemory } from '../memory/memories.js';
+import { getDbClient } from '../lib/db-client.js';
 /**
  * Initialize or get a context session
  * Simplified - just tracks what's loaded, not tokens (Claude manages its own context)
  */
 export async function initializeContextSession(sessionId, projectId, userId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     // Check if session exists
     const existing = await db
@@ -46,11 +35,9 @@ export async function initializeContextSession(sessionId, projectId, userId) {
 }
 /**
  * Load a memory into working set
- * Note: Claude manages its own context - this just tracks what you've loaded
  */
 export async function loadMemoryToContext(sessionId, memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     // Get session
     const session = await db
@@ -74,7 +61,7 @@ export async function loadMemoryToContext(sessionId, memoryId) {
         };
     }
     // Get memory
-    const memory = await getMemoryById(memoryId);
+    const memory = await getMemory(memoryId);
     if (!memory) {
         return {
             success: false,
@@ -112,8 +99,7 @@ export async function loadMemoryToContext(sessionId, memoryId) {
  * Evict a memory from working set
  */
 export async function evictMemoryFromContext(sessionId, memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     // Get session
     const session = await db
@@ -161,8 +147,7 @@ export async function evictMemoryFromContext(sessionId, memoryId) {
  * View all memories in working set
  */
 export async function viewLoadedMemories(sessionId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     // Get session
     const session = await db
@@ -189,7 +174,7 @@ export async function viewLoadedMemories(sessionId) {
     // Get all loaded memories
     const memories = [];
     for (const id of loadedIds) {
-        const memory = await getMemoryById(id);
+        const memory = await getMemory(id);
         if (memory) {
             memories.push({
                 id: memory.id,
@@ -208,12 +193,10 @@ export async function viewLoadedMemories(sessionId) {
 }
 /**
  * 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 async function getContextStatus(sessionId, projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { contextSessions, memories, observations } = schema;
+    const { db, schema } = await getDbClient();
+    const { contextSessions, memories, learnings } = schema;
     // Get session
     const session = await db
         .select()
@@ -231,13 +214,13 @@ export async function getContextStatus(sessionId, projectId) {
     }
     const currentSession = session[0];
     // Get core memory stats
-    const { getCoreMemoryStats } = await import('./core-memory.js');
+    const { getCoreMemoryStats } = await import('../ingestion/core-memory.js');
     const coreStats = await getCoreMemoryStats(projectId);
     // Get loaded memories
     const loadedIds = currentSession.loadedMemoryIds || [];
     const loadedMemories = [];
     for (const id of loadedIds) {
-        const memory = await getMemoryById(id);
+        const memory = await getMemory(id);
         if (memory) {
             loadedMemories.push({
                 id: memory.id,
@@ -253,8 +236,8 @@ export async function getContextStatus(sessionId, projectId) {
         .where(eq(memories.projectId, projectId));
     const totalObservations = await db
         .select()
-        .from(observations)
-        .where(eq(observations.projectId, projectId));
+        .from(learnings)
+        .where(eq(learnings.projectId, projectId));
     return {
         success: true,
         coreMemory: {
@@ -277,8 +260,7 @@ export async function getContextStatus(sessionId, projectId) {
  * Clear all loaded memories from working set
  */
 export async function clearLoadedMemories(sessionId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     await db
         .update(contextSessions)
@@ -296,8 +278,7 @@ export async function clearLoadedMemories(sessionId) {
  * Get all memories currently marked as in-context for a session
  */
 export async function getInContextMemories(sessionId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { contextSessions } = schema;
     // Get session to find project
     const session = await db
@@ -327,8 +308,7 @@ export async function getInContextMemories(sessionId) {
  * Get out-of-context (archived) memories for a project
  */
 export async function getOutOfContextMemories(projectId, limit = 10) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const { memories } = schema;
     // Get out-of-context memories, ordered by last accessed
     const outOfContextMemories = await db

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

@@ -0,0 +1,40 @@
+export interface ContextWindowConfig {
+    maxTokens: number;
+    warningThreshold: number;
+    criticalThreshold: number;
+}
+export declare const DEFAULT_CONTEXT_CONFIG: ContextWindowConfig;
+export interface TokenUsageStats {
+    coreMemoryTokens: number;
+    memoriesTokens: number;
+    totalTokens: number;
+    maxTokens: number;
+    usagePercent: number;
+    status: 'ok' | 'warning' | 'critical';
+    remainingTokens: number;
+}
+export interface OptimizationSuggestion {
+    type: 'drop' | 'summarize' | 'consolidate';
+    memoryId: string;
+    memoryType: string;
+    contentPreview: string;
+    tokens: number;
+    reason: string;
+    priority: number;
+}
+export declare function estimateTokens(content: string): number;
+export declare function getTokenUsage(projectPath: string): Promise<TokenUsageStats>;
+export declare function checkContextLimit(projectPath: string, additionalTokens: number): Promise<{
+    ok: boolean;
+    warning?: string;
+    stats: TokenUsageStats;
+}>;
+export declare function getOptimizationSuggestions(projectPath: string): Promise<OptimizationSuggestion[]>;
+export declare function getContextWindowStatus(projectPath: string): Promise<{
+    config: ContextWindowConfig;
+    usage: TokenUsageStats;
+    suggestions: OptimizationSuggestion[];
+    memoryCount: number;
+    coreMemorySections: number;
+}>;
+//# sourceMappingURL=context-window.d.ts.map