squish-memory 1.2.0 → 1.2.1

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

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

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

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

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

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

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

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

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

@@ -1,137 +0,0 @@
-/**
- * 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: "startup";
-        resume: "resume";
-        compact: "compact";
-    }>>;
-    sessionId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-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>;
-}, z.core.$strip>;
-export declare const TimelineInputSchema: z.ZodObject<{
-    query: z.ZodString;
-    depth: z.ZodDefault<z.ZodEnum<{
-        index: "index";
-        timeline: "timeline";
-        detail: "detail";
-    }>>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-/** 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