squish-memory 1.0.2 → 1.1.5

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

@@ -0,0 +1,45 @@
+/**
+ * UAM Adapter Registry
+ *
+ * Manages agent adapters for Universal Agent Memory.
+ * Provides functions to register, retrieve, and list adapters.
+ */
+import { AgentAdapter, AgentType, AgentConfig } from './types.js';
+/**
+ * Register an adapter
+ */
+export declare function registerAdapter(adapter: AgentAdapter): void;
+/**
+ * Get adapter by type
+ */
+export declare function getAdapter(type: AgentType): AgentAdapter | undefined;
+/**
+ * List all registered adapters
+ */
+export declare function listAdapters(): AgentAdapter[];
+/**
+ * Load all adapters from config directory
+ */
+export declare function loadAllAdapters(dir: string): Promise<void>;
+/**
+ * Get adapter config by type (for native integration)
+ */
+export declare function getAdapterConfig(type: AgentType): AgentConfig | undefined;
+/**
+ * List all adapter configs (for MCP tool)
+ */
+export declare function listAdapterConfigs(): AgentConfig[];
+/**
+ * Check if an adapter is registered
+ */
+export declare function hasAdapter(type: AgentType): boolean;
+/**
+ * Clear all adapters (mainly for testing)
+ */
+export declare function clearAdapters(): void;
+export * from './types.js';
+export type { AgentAdapter, AgentType, AgentConfig };
+export type { SessionContextInput, SessionContextOutput } from './types.js';
+export type { ToolObservationInput, ToolObservationOutput } from './types.js';
+export type { TimelineDepth } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/adapters/index.js

@@ -0,0 +1,84 @@
+/**
+ * UAM Adapter Registry
+ *
+ * Manages agent adapters for Universal Agent Memory.
+ * Provides functions to register, retrieve, and list adapters.
+ */
+import { logger } from '../logger.js';
+/** In-memory adapter registry */
+const adapters = new Map();
+/** Config directory for agent configs */
+let configDir = null;
+/**
+ * Register an adapter
+ */
+export function registerAdapter(adapter) {
+    if (adapters.has(adapter.type)) {
+        logger.warn(`[Adapters] Overriding existing adapter for type: ${adapter.type}`);
+    }
+    adapters.set(adapter.type, adapter);
+    logger.info(`[Adapters] Registered adapter: ${adapter.name} (${adapter.type})`);
+}
+/**
+ * Get adapter by type
+ */
+export function getAdapter(type) {
+    return adapters.get(type);
+}
+/**
+ * List all registered adapters
+ */
+export function listAdapters() {
+    return Array.from(adapters.values());
+}
+/**
+ * Load all adapters from config directory
+ */
+export async function loadAllAdapters(dir) {
+    configDir = dir;
+    logger.info(`[Adapters] Loading adapters from: ${dir}`);
+    // Dynamic import and register adapters
+    try {
+        const { registerClaudeCodeAdapter } = await import('./config/claude-code.js');
+        const { registerOpenCodeAdapter } = await import('./config/opencode.js');
+        const { registerCursorAdapter } = await import('./config/cursor.js');
+        const { registerWindsurfAdapter } = await import('./config/windsurf.js');
+        registerClaudeCodeAdapter();
+        registerOpenCodeAdapter();
+        registerCursorAdapter();
+        registerWindsurfAdapter();
+        logger.info(`[Adapters] Loaded ${listAdapters().length} adapters`);
+    }
+    catch (error) {
+        logger.error(`[Adapters] Failed to load adapters:`, error);
+    }
+}
+/**
+ * Get adapter config by type (for native integration)
+ */
+export function getAdapterConfig(type) {
+    const adapter = adapters.get(type);
+    return adapter?.getNativeConfig();
+}
+/**
+ * List all adapter configs (for MCP tool)
+ */
+export function listAdapterConfigs() {
+    return listAdapters().map(a => a.getNativeConfig());
+}
+/**
+ * Check if an adapter is registered
+ */
+export function hasAdapter(type) {
+    return adapters.has(type);
+}
+/**
+ * Clear all adapters (mainly for testing)
+ */
+export function clearAdapters() {
+    adapters.clear();
+    logger.info('[Adapters] Cleared all adapters');
+}
+// Re-export types
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/core/adapters/scripts/install-adapter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Install Adapter Script
+ *
+ * Installs Squish MCP configuration for various AI coding agents.
+ * Run with: bun run core/adapters/scripts/install-adapter.ts --agent claude-code
+ */
+interface InstallOptions {
+    agent: 'claude-code' | 'opencode' | 'cursor' | 'windsurf';
+    projectRoot?: string;
+    dryRun?: boolean;
+}
+declare const AGENT_CONFIG_PATHS: Record<string, {
+    dir: string;
+    file: string;
+}>;
+declare const MCP_CONFIGS: Record<string, object>;
+declare function installAdapter(options: InstallOptions): void;
+export { installAdapter, AGENT_CONFIG_PATHS, MCP_CONFIGS };
+//# sourceMappingURL=install-adapter.d.ts.map

package/dist/core/adapters/scripts/install-adapter.js

@@ -0,0 +1,149 @@
+/**
+ * Install Adapter Script
+ *
+ * Installs Squish MCP configuration for various AI coding agents.
+ * Run with: bun run core/adapters/scripts/install-adapter.ts --agent claude-code
+ */
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+// Config paths per agent
+const AGENT_CONFIG_PATHS = {
+    'claude-code': {
+        dir: '.claude',
+        file: 'settings.json',
+    },
+    'opencode': {
+        dir: '.opencode',
+        file: 'settings.json',
+    },
+    'cursor': {
+        dir: '.cursor',
+        file: 'mcp.json',
+    },
+    'windsurf': {
+        dir: '.windsurf',
+        file: 'config.json',
+    },
+};
+// MCP config templates
+const MCP_CONFIGS = {
+    'claude-code': {
+        mcpServers: {
+            squish: {
+                command: 'node',
+                args: ['dist/core/commands/mcp-server.js'],
+                env: { NODE_ENV: 'production' }
+            }
+        }
+    },
+    'opencode': {
+        mcpServers: {
+            squish: {
+                command: 'node',
+                args: ['dist/core/commands/mcp-server.js']
+            }
+        }
+    },
+    'cursor': {
+        mcpServers: {
+            squish: {
+                command: 'node',
+                args: ['dist/core/commands/mcp-server.js'],
+                env: { NODE_ENV: 'production' }
+            }
+        }
+    },
+    'windsurf': {
+        mcpServers: {
+            squish: {
+                command: 'node',
+                args: ['dist/core/commands/mcp-server.js'],
+                env: { NODE_ENV: 'production' }
+            }
+        }
+    }
+};
+function getConfigPath(agent) {
+    const home = homedir();
+    const config = AGENT_CONFIG_PATHS[agent];
+    return join(home, config.dir, config.file);
+}
+function installAdapter(options) {
+    const { agent, projectRoot, dryRun } = options;
+    const configPath = projectRoot
+        ? join(projectRoot, AGENT_CONFIG_PATHS[agent].dir, AGENT_CONFIG_PATHS[agent].file)
+        : getConfigPath(agent);
+    const configDir = dirname(configPath);
+    const config = MCP_CONFIGS[agent];
+    console.log(`Installing Squish MCP for ${agent}...`);
+    console.log(`Config path: ${configPath}`);
+    if (dryRun) {
+        console.log(`[DRY RUN] Would write:`);
+        console.log(JSON.stringify(config, null, 2));
+        return;
+    }
+    // Create directory if needed
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+        console.log(`Created directory: ${configDir}`);
+    }
+    // Check if file exists and merge
+    let existingConfig = {};
+    if (existsSync(configPath)) {
+        try {
+            const existing = require('fs').readFileSync(configPath, 'utf-8');
+            existingConfig = JSON.parse(existing);
+            console.log(`Merging with existing config...`);
+        }
+        catch {
+            console.log(`Warning: Could not parse existing config, overwriting`);
+        }
+    }
+    // Merge configs - simplified
+    const mergedConfig = {
+        ...existingConfig,
+        mcpServers: {
+            ...(existingConfig.mcpServers || {}),
+            ...MCP_CONFIGS[agent].mcpServers
+        }
+    };
+    // Write config
+    writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
+    console.log(`Config written to: ${configPath}`);
+    console.log(`\nTo activate:`);
+    console.log(`  1. Restart ${agent}`);
+    console.log(`  2. Or reload settings`);
+}
+// CLI handler
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    let agent = 'claude-code';
+    let dryRun = false;
+    let projectRoot;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--agent' && args[i + 1]) {
+            agent = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--dry-run') {
+            dryRun = true;
+        }
+        else if (args[i] === '--project' && args[i + 1]) {
+            projectRoot = args[i + 1];
+            i++;
+        }
+    }
+    if (!['claude-code', 'opencode', 'cursor', 'windsurf'].includes(agent)) {
+        console.error(`Unknown agent: ${agent}`);
+        console.log(`Usage: install-adapter.ts --agent [claude-code|opencode|cursor|windsurf] [--dry-run] [--project <path>]`);
+        process.exit(1);
+    }
+    installAdapter({
+        agent: agent,
+        projectRoot,
+        dryRun
+    });
+}
+export { installAdapter, AGENT_CONFIG_PATHS, MCP_CONFIGS };
+//# sourceMappingURL=install-adapter.js.map

package/dist/core/adapters/timeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Timeline Implementation - 3-Layer Progressive Disclosure
+ *
+ * Provides timeline functionality for MCP tool with depth parameter.
+ * Layer 1 (index): ~50 tokens - memory titles only
+ * Layer 2 (timeline): ~200 tokens - titles + timestamps + tags
+ * Layer 3 (detail): ~2000 tokens - full content
+ */
+import { TimelineDepth } from './types.js';
+/**
+ * Get timeline with progressive disclosure
+ */
+export declare function getTimeline(query: string, depth?: TimelineDepth, limit?: number, project?: string): Promise<{
+    results: unknown[];
+    layer: TimelineDepth;
+    tokenEstimate: number;
+    query: string;
+}>;
+/**
+ * Get memory by ID with optional depth
+ */
+export declare function getMemoryTimeline(memoryId: string, depth?: TimelineDepth): Promise<unknown>;
+//# sourceMappingURL=timeline.d.ts.map

package/dist/core/adapters/timeline.js

@@ -0,0 +1,88 @@
+/**
+ * Timeline Implementation - 3-Layer Progressive Disclosure
+ *
+ * Provides timeline functionality for MCP tool with depth parameter.
+ * Layer 1 (index): ~50 tokens - memory titles only
+ * Layer 2 (timeline): ~200 tokens - titles + timestamps + tags
+ * Layer 3 (detail): ~2000 tokens - full content
+ */
+import { search as searchMemories, getMemory } from '../memory/memories.js';
+/** Token estimates per layer */
+const LAYER_TOKENS = {
+    index: 50,
+    timeline: 200,
+    detail: 2000,
+};
+/**
+ * Get timeline with progressive disclosure
+ */
+export async function getTimeline(query, depth = 'index', limit = 10, project) {
+    // First get search results
+    const memories = await searchMemories({
+        query,
+        project,
+        limit,
+    });
+    // Format based on depth
+    let results;
+    let tokenEstimate = 0;
+    switch (depth) {
+        case 'index':
+            results = memories.map(m => ({
+                id: m.id,
+                title: `${m.type}: ${m.content?.substring(0, 60)}...`,
+            }));
+            tokenEstimate = results.length * (LAYER_TOKENS.index / Math.max(results.length, 1));
+            break;
+        case 'timeline':
+            results = memories.map(m => ({
+                id: m.id,
+                type: m.type,
+                content: m.content?.substring(0, 100),
+                tags: m.tags,
+                createdAt: m.createdAt,
+            }));
+            tokenEstimate = results.length * (LAYER_TOKENS.timeline / Math.max(results.length, 1));
+            break;
+        case 'detail':
+            results = await Promise.all(memories.map(async (m) => {
+                const full = await getMemory(m.id);
+                return full || { id: m.id, error: 'Not found' };
+            }));
+            tokenEstimate = LAYER_TOKENS.detail;
+            break;
+    }
+    return {
+        results,
+        layer: depth,
+        tokenEstimate,
+        query,
+    };
+}
+/**
+ * Get memory by ID with optional depth
+ */
+export async function getMemoryTimeline(memoryId, depth = 'detail') {
+    const memory = await getMemory(memoryId);
+    if (!memory) {
+        return { error: 'Memory not found', id: memoryId };
+    }
+    if (depth === 'index') {
+        return {
+            id: memory.id,
+            title: `${memory.type}: ${memory.content?.substring(0, 60)}...`,
+        };
+    }
+    if (depth === 'timeline') {
+        return {
+            id: memory.id,
+            type: memory.type,
+            content: memory.content?.substring(0, 100),
+            tags: memory.tags,
+            createdAt: memory.createdAt,
+        };
+    }
+    // detail
+    return memory;
+}
+//# sourceMappingURL=timeline.js.map

package/dist/core/adapters/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * UAM Adapter Types
+ *
+ * Universal Agent Memory - Adapter interfaces for different AI coding agents.
+ * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
+ * that defines how to integrate with Squish.
+ *
+ * Key concepts:
+ * - Agent adapters use native config formats where possible
+ * - Hooks are explicit (calls squish_learn) not hidden
+ * - Uses existing MCP tools (squish_context, squish_learn)
+ */
+import { z } from 'zod';
+/** Agent types supported by UAM */
+export type AgentType = 'claude-code' | 'opencode' | 'cursor' | 'windsurf' | 'codex' | 'generic';
+/** Hook event types */
+export type HookEvent = 'onSessionStart' | 'onSessionEnd' | 'onToolCall' | 'onPreCompact' | 'onPostCompact';
+/** 3-Layer depth for progressive disclosure */
+export type TimelineDepth = 'index' | 'timeline' | 'detail';
+/** Memory context for session start */
+export interface SessionContextInput {
+    project: string;
+    mode: 'startup' | 'resume' | 'compact';
+    sessionId?: string;
+}
+export interface SessionContextOutput {
+    mode: string;
+    project: string;
+    memories: string;
+    count: number;
+    snapshot?: {
+        id: string;
+        content: string;
+    } | null;
+}
+/** Tool call observation */
+export interface ToolObservationInput {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolResult: unknown;
+    project: string;
+    sessionId?: string;
+}
+export interface ToolObservationOutput {
+    memoryId: string;
+    category: 'reading' | 'modification' | 'commit' | 'testing' | 'command' | 'search' | 'planning' | 'other';
+    content: string;
+}
+/** Agent configuration */
+export interface AgentConfig {
+    /** Unique agent identifier */
+    agentId: string;
+    /** Human-readable name */
+    name: string;
+    /** Agent type */
+    type: AgentType;
+    /** MCP server configuration */
+    mcp: {
+        command: string;
+        args: string[];
+        env?: Record<string, string>;
+    };
+    /** Hook patterns (native format for each agent) */
+    hooks?: {
+        sessionStart?: unknown;
+        sessionEnd?: unknown;
+        preCompact?: unknown;
+        postToolUse?: unknown;
+    };
+    /** Custom settings */
+    settings?: Record<string, unknown>;
+}
+/** Agent adapter interface */
+export interface AgentAdapter {
+    /** Unique adapter ID */
+    id: string;
+    /** Agent type */
+    type: AgentType;
+    /** Human-readable name */
+    name: string;
+    /** Agent version (if known) */
+    version?: string;
+    /** Get session context for injection */
+    getSessionContext(input: SessionContextInput): Promise<SessionContextOutput>;
+    /** Record a tool observation */
+    recordObservation(input: ToolObservationInput): Promise<ToolObservationOutput>;
+    /** Get timeline (3-layer progressive disclosure) */
+    getTimeline(query: string, depth: TimelineDepth, limit: number): Promise<unknown[]>;
+    /** Check if this agent should capture this tool */
+    shouldCaptureTool(toolName: string): boolean;
+    /** Get raw config for native integration */
+    getNativeConfig(): AgentConfig;
+}
+/** Registry for managing adapters */
+export interface AdapterRegistry {
+    /** Register a new adapter */
+    register(adapter: AgentAdapter): void;
+    /** Get adapter by type */
+    get(type: AgentType): AgentAdapter | undefined;
+    /** List all registered adapters */
+    list(): AgentAdapter[];
+    /** Load all adapters from config directory */
+    loadAll(configDir: string): Promise<void>;
+}
+/** Zod schemas for validation */
+export declare const SessionContextInputSchema: z.ZodObject<{
+    project: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["startup", "resume", "compact"]>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    mode: "resume" | "startup" | "compact";
+    sessionId?: string | undefined;
+}, {
+    project: string;
+    mode?: "resume" | "startup" | "compact" | undefined;
+    sessionId?: string | undefined;
+}>;
+export declare const ToolObservationInputSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    toolInput: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    toolResult: z.ZodUnknown;
+    project: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    sessionId?: string | undefined;
+    toolResult?: unknown;
+}, {
+    project: string;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    sessionId?: string | undefined;
+    toolResult?: unknown;
+}>;
+export declare const TimelineInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    depth: z.ZodDefault<z.ZodEnum<["index", "timeline", "detail"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    limit: number;
+    depth: "index" | "timeline" | "detail";
+}, {
+    query: string;
+    limit?: number | undefined;
+    depth?: "index" | "timeline" | "detail" | undefined;
+}>;
+/** Tool category mapping */
+export declare const TOOL_CATEGORIES: Record<string, ToolObservationOutput['category']>;
+/**
+ * Categorize a tool call
+ */
+export declare function categorizeTool(toolName: string): ToolObservationOutput['category'];
+//# sourceMappingURL=types.d.ts.map

package/dist/core/adapters/types.js

@@ -0,0 +1,50 @@
+/**
+ * UAM Adapter Types
+ *
+ * Universal Agent Memory - Adapter interfaces for different AI coding agents.
+ * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
+ * that defines how to integrate with Squish.
+ *
+ * Key concepts:
+ * - Agent adapters use native config formats where possible
+ * - Hooks are explicit (calls squish_learn) not hidden
+ * - Uses existing MCP tools (squish_context, squish_learn)
+ */
+import { z } from 'zod';
+/** Zod schemas for validation */
+export const SessionContextInputSchema = z.object({
+    project: z.string(),
+    mode: z.enum(['startup', 'resume', 'compact']).default('startup'),
+    sessionId: z.string().optional(),
+});
+export const ToolObservationInputSchema = z.object({
+    toolName: z.string(),
+    toolInput: z.record(z.unknown()),
+    toolResult: z.unknown(),
+    project: z.string(),
+    sessionId: z.string().optional(),
+});
+export const TimelineInputSchema = z.object({
+    query: z.string(),
+    depth: z.enum(['index', 'timeline', 'detail']).default('index'),
+    limit: z.number().min(1).max(100).default(10),
+});
+/** Tool category mapping */
+export const TOOL_CATEGORIES = {
+    'Read': 'reading',
+    'Write': 'modification',
+    'Edit': 'modification',
+    'Bash': 'command',
+    'grep': 'search',
+    'Glob': 'search',
+    'TodoWrite': 'planning',
+    'TodoRead': 'planning',
+    'Task': 'planning',
+};
+/**
+ * Categorize a tool call
+ */
+export function categorizeTool(toolName) {
+    return TOOL_CATEGORIES[toolName] || 'other';
+}
+//# sourceMappingURL=types.js.map

package/dist/{algorithms → core/algorithms}/analytics/token-estimator.d.ts

@@ -2,7 +2,7 @@
  * Token estimation for calculating context window savings from merges.
  * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
  */
-import type { Memory } from '../../drizzle/schema.js';
+import type { Memory } from '../../../db/drizzle/schema.js';
 import type { MergedMemory } from '../strategies/merge-strategies.js';
 export declare function estimateTokensSaved(sources: Memory[], merged: MergedMemory): number;
 export declare function calculateProjectTokenSavings(projectId: string): Promise<{

package/dist/{algorithms → core/algorithms}/analytics/token-estimator.js

@@ -2,9 +2,9 @@
  * Token estimation for calculating context window savings from merges.
  * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 function estimateTokensSimple(text) {
     if (!text)

package/dist/{algorithms → core/algorithms}/detection/semantic-ranker.d.ts

@@ -2,7 +2,7 @@
  * Semantic ranking using embeddings (Stage 2 of two-stage detection).
  * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
  */
-import type { Memory } from '../../drizzle/schema.js';
+import type { Memory } from '../../../db/drizzle/schema.js';
 export interface RankedCandidate {
     memoryId1: string;
     memoryId2: string;

package/dist/{algorithms → core/algorithms}/detection/semantic-ranker.js

@@ -2,7 +2,7 @@
  * Semantic ranking using embeddings (Stage 2 of two-stage detection).
  * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
  */
-import { cosineSimilarity } from '../../core/local-embeddings.js';
+import { cosineSimilarity } from '../../../core/utils/vector-operations.js';
 function calculateConfidence(memory1, memory2, cosineSim) {
     if (cosineSim >= 0.90) {
         const factors = calculateConfidenceFactors(memory1, memory2);

package/dist/{algorithms → core/algorithms}/detection/two-stage-detector.d.ts

@@ -4,7 +4,7 @@
  * Stage 1: Hash-based prefiltering (SimHash + MinHash)
  * Stage 2: Semantic ranking using embeddings
  */
-import type { Memory, MemoryType } from '../../drizzle/schema.js';
+import type { Memory, MemoryType } from '../../../db/drizzle/schema.js';
 import { analyzePair } from './semantic-ranker.js';
 export interface MemoryPair {
     memory1: Memory;