squish-memory 1.0.2 → 1.2.0

package/dist/core/adapters/config/opencode.js

@@ -0,0 +1,73 @@
+/**
+ * OpenCode Adapter Configuration
+ *
+ * Native OpenCode configuration for integrating Squish as MCP server.
+ * OpenCode uses similar MCP configuration to Claude Code.
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'opencode',
+    name: 'OpenCode',
+    type: 'opencode',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {},
+    settings: {
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register OpenCode adapter
+ */
+export function registerOpenCodeAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'opencode',
+        type: 'opencode',
+        name: 'OpenCode',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return { mode: input.mode, project: input.project, memories, count: recent.length };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            const memory = await createLearning({
+                type: 'insight',
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                project: input.project,
+                autoLink: false,
+            });
+            return { memoryId: memory.id, category: 'other', content: `Recorded: ${input.toolName}` };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            return ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'].includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+}
+/** OpenCode settings.json format */
+export const OPENCODE_SETTINGS = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"]
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=opencode.js.map

package/dist/core/adapters/config/windsurf.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Windsurf Adapter Configuration
+ *
+ * Native Windsurf configuration for integrating Squish as MCP server.
+ * Windsurf uses .windsurf/config.json format.
+ */
+import { AgentConfig } from '../types.js';
+declare const ADAPTER_CONFIG: AgentConfig;
+/**
+ * Register Windsurf adapter
+ */
+export declare function registerWindsurfAdapter(): void;
+/** Windsurf config.json format */
+export declare const WINDSURF_CONFIG: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+            env: {
+                NODE_ENV: string;
+            };
+        };
+    };
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=windsurf.d.ts.map

package/dist/core/adapters/config/windsurf.js

@@ -0,0 +1,74 @@
+/**
+ * Windsurf Adapter Configuration
+ *
+ * Native Windsurf configuration for integrating Squish as MCP server.
+ * Windsurf uses .windsurf/config.json format.
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'windsurf',
+    name: 'Windsurf',
+    type: 'windsurf',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {},
+    settings: {
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register Windsurf adapter
+ */
+export function registerWindsurfAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'windsurf',
+        type: 'windsurf',
+        name: 'Windsurf',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return { mode: input.mode, project: input.project, memories, count: recent.length };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            const memory = await createLearning({
+                type: 'insight',
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                project: input.project,
+                autoLink: false,
+            });
+            return { memoryId: memory.id, category: 'other', content: `Recorded: ${input.toolName}` };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            return ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'].includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+}
+/** Windsurf config.json format */
+export const WINDSURF_CONFIG = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"],
+            "env": { "NODE_ENV": "production" }
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=windsurf.js.map

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