squish-memory 1.1.5 → 1.2.1

package/{dist/core/lib/schemas.js → core/lib/schemas.ts}

@@ -1,87 +1,102 @@
-/**
- * Shared Zod schemas for input validation across Squish
- * Provides consistent validation for common input types
- */
-import { z } from 'zod';
-/**
- * Limit schema: integer between 1 and 100, default 20
- */
-export const limitSchema = z.number().int().min(1).max(100).default(20);
-/**
- * Offset schema: integer >= 0, default 0
- */
-export const offsetSchema = z.number().int().min(0).default(0);
-/**
- * Project ID/path schema: non-empty string
- */
-export const projectIdSchema = z.string().min(1);
-/**
- * Memory ID schema: valid UUID
- */
-export const memoryIdSchema = z.string().uuid();
-/**
- * Pagination schema combining limit and offset
- */
-export const paginationSchema = z.object({
-    limit: limitSchema,
-    offset: offsetSchema,
-});
-/**
- * Search query schema: non-empty string
- */
-export const searchQuerySchema = z.string().min(1).trim();
-/**
- * Memory type schema
- */
-export const memoryTypeSchema = z.enum(['observation', 'fact', 'decision', 'context', 'preference', 'note']);
-/**
- * Association type schema
- */
-export const associationTypeSchema = z.enum(['relates_to', 'supports', 'contradicts', 'supersedes', 'duplicate']);
-/**
- * Weight schema: number between 0 and 1
- */
-export const weightSchema = z.number().min(0).max(1);
-/**
- * Learning type schema
- */
-export const learningTypeSchema = z.enum(['success', 'failure', 'fix', 'observation']);
-/**
- * Observation type schema
- */
-export const observationTypeSchema = z.enum(['tool_use', 'file_change', 'error', 'pattern', 'insight']);
-/**
- * Confidence level schema
- */
-export const confidenceLevelSchema = z.enum(['certain', 'speculative', 'outdated']);
-/**
- * Search input schema (common for search operations)
- */
-export const searchInputSchema = z.object({
-    query: searchQuerySchema,
-    limit: limitSchema.optional(),
-    offset: offsetSchema.optional(),
-    project: projectIdSchema.optional(),
-    type: memoryTypeSchema.optional(),
-});
-/**
- * Memory recall schema
- */
-export const recallInputSchema = z.object({
-    memoryId: memoryIdSchema,
-    limit: limitSchema.optional(),
-    project: projectIdSchema.optional(),
-});
-/**
- * Tag operation schema
- */
-export const tagOperationSchema = z.object({
-    action: z.enum(['add', 'remove']),
-    tag: z.string().min(1),
-    search: z.string().optional(),
-    olderThan: z.string().optional(),
-    type: memoryTypeSchema.optional(),
-    limit: limitSchema.optional(),
-    project: projectIdSchema.optional(),
-});
-//# sourceMappingURL=schemas.js.map
+/**
+ * Shared Zod schemas for input validation across Squish
+ * Provides consistent validation for common input types
+ */
+
+import { z } from 'zod';
+
+/**
+ * Limit schema: integer between 1 and 100, default 20
+ */
+export const limitSchema = z.number().int().min(1).max(100).default(20);
+
+/**
+ * Offset schema: integer >= 0, default 0
+ */
+export const offsetSchema = z.number().int().min(0).default(0);
+
+/**
+ * Project ID/path schema: non-empty string
+ */
+export const projectIdSchema = z.string().min(1);
+
+/**
+ * Memory ID schema: valid UUID
+ */
+export const memoryIdSchema = z.string().uuid();
+
+/**
+ * Pagination schema combining limit and offset
+ */
+export const paginationSchema = z.object({
+  limit: limitSchema,
+  offset: offsetSchema,
+});
+
+/**
+ * Search query schema: non-empty string
+ */
+export const searchQuerySchema = z.string().min(1).trim();
+
+/**
+ * Memory type schema
+ */
+export const memoryTypeSchema = z.enum(['observation', 'fact', 'decision', 'context', 'preference', 'note']);
+
+/**
+ * Association type schema
+ */
+export const associationTypeSchema = z.enum(['relates_to', 'supports', 'contradicts', 'supersedes', 'duplicate']);
+
+/**
+ * Weight schema: number between 0 and 1
+ */
+export const weightSchema = z.number().min(0).max(1);
+
+/**
+ * Learning type schema
+ */
+export const learningTypeSchema = z.enum(['success', 'failure', 'fix', 'observation']);
+
+/**
+ * Observation type schema
+ */
+export const observationTypeSchema = z.enum(['tool_use', 'file_change', 'error', 'pattern', 'insight']);
+
+/**
+ * Confidence level schema
+ */
+export const confidenceLevelSchema = z.enum(['certain', 'speculative', 'outdated']);
+
+/**
+ * Search input schema (common for search operations)
+ */
+export const searchInputSchema = z.object({
+  query: searchQuerySchema,
+  limit: limitSchema.optional(),
+  offset: offsetSchema.optional(),
+  project: projectIdSchema.optional(),
+  type: memoryTypeSchema.optional(),
+});
+
+/**
+ * Memory recall schema
+ */
+export const recallInputSchema = z.object({
+  memoryId: memoryIdSchema,
+  limit: limitSchema.optional(),
+  project: projectIdSchema.optional(),
+});
+
+/**
+ * Tag operation schema
+ */
+export const tagOperationSchema = z.object({
+  action: z.enum(['add', 'remove']),
+  tag: z.string().min(1),
+  search: z.string().optional(),
+  olderThan: z.string().optional(),
+  type: memoryTypeSchema.optional(),
+  limit: limitSchema.optional(),
+  project: projectIdSchema.optional(),
+});

package/core/lib/types.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared type definitions for Squish Memory system
+ * Consolidated from core/memory/memories.ts and core/memory/normalization.ts
+ */
+
+// Valid memory type values
+export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'note' | 'task';
+
+/**
+ * Confidence level for memory records
+ * - certain: High confidence, verified information
+ * - speculative: Low confidence, unverified or uncertain
+ * - outdated: Information that may no longer be accurate
+ */
+export type ConfidenceLevel = 'certain' | 'speculative' | 'outdated';
+
+/**
+ * Unified MemoryRecord interface
+ * Used across memories.ts and normalization.ts
+ *
+ * Note: type is string to avoid circular dependency with memories.ts
+ * Use MemoryType for type checking when needed
+ */
+export interface MemoryRecord {
+  id: string;
+  projectId?: string | null;
+  type: string; // Stored as string in DB (use MemoryType for valid values)
+  content: string;
+  summary?: string | null;
+  tags: string[];
+  metadata?: Record<string, unknown> | null;
+  createdAt?: string | null;
+  validFrom?: string | null;
+  validTo?: string | null;
+  recordedAt?: string | null;
+  similarity?: number;
+  importance?: number;
+  confidenceLevel?: ConfidenceLevel | null;
+}
+
+/**
+ * Result of a safety check
+ * Used to determine if a merge action can proceed
+ */
+export interface SafetyCheckResult {
+  passed: boolean;
+  warnings: string[];
+  blockers: string[]; // Hard failures
+}

package/core/lib/utils.ts

@@ -0,0 +1,151 @@
+/**
+ * Shared utility functions for the squish codebase
+ */
+
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { config } from '../../config.js';
+import { toSqliteJson } from '../memory/serialization.js';
+
+export function normalizeTimestamp(value: any): string | null {
+  if (!value) return null;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === 'number') {
+    try {
+      // Handle different timestamp formats using magnitude thresholds
+      // Microseconds: > 100000000000000 (e.g., 1700000000000000)
+      // Milliseconds: > 1000000000000 (e.g., 1700000000000)
+      // Seconds: <= 1000000000000 (e.g., 1700000000)
+      if (value > 100000000000000) {
+        return new Date(value / 1000).toISOString();
+      } else if (value > 1000000000000) {
+        return new Date(value).toISOString();
+      } else if (value >= 0) {
+        return new Date(value * 1000).toISOString();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value === 'string') {
+    try {
+      const parsed = new Date(value);
+      if (!isNaN(parsed.getTime())) return parsed.toISOString();
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function now(): string {
+  return new Date().toISOString();
+}
+
+export function isDatabaseUnavailableError(error: any): boolean {
+  const message = error?.message || '';
+  return [
+    'Database unavailable',
+    'not a valid Win32 application',
+    'invalid ELF header',
+    'bun:',
+    'sql.js wasm asset not found',
+    'SQLite database initialization failed',
+    'working local SQLite driver',
+  ].some((pattern) => message.includes(pattern));
+}
+
+export async function withDatabaseErrorHandling<T>(
+  operation: () => Promise<T>,
+  errorMessage: string
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (dbError: any) {
+    if (isDatabaseUnavailableError(dbError)) {
+      throw new McpError(ErrorCode.InternalError, errorMessage);
+    }
+    throw dbError;
+  }
+}
+
+export function clampLimit(value: number | undefined, defaultValue: number, min: number = 1, max: number = 100): number {
+  return Math.min(Math.max(value ?? defaultValue, min), max);
+}
+
+export function prepareEmbedding(embedding: number[] | null): { embedding?: number[] | null; embeddingJson?: string | null } {
+  if (config.isTeamMode) {
+    return { embedding: embedding ?? null };
+  }
+  return { embeddingJson: toSqliteJson(embedding ?? null) };
+}
+
+export function determineOverallStatus(dbStatus: string, redisOk: boolean): string {
+  if ((dbStatus === 'ok' || dbStatus === 'unavailable') && redisOk) {
+    return 'ok';
+  }
+  if (dbStatus === 'unavailable') {
+    return 'degraded';
+  }
+  return 'error';
+}
+
+// Date parsing utilities - shared between CLI and MCP
+// ============================================================================
+
+export function parseDate(input: string): Date | null {
+  if (!input) return null;
+  const now = new Date();
+  const lower = input.toLowerCase().trim();
+  
+  // Direct date parse
+  const parsed = new Date(input);
+  if (!isNaN(parsed.getTime())) return parsed;
+  
+  // Relative parsing
+  const dayMatch = lower.match(/(\d+)\s*day/i);
+  const weekMatch = lower.match(/(\d+)\s*week/i);
+  const monthMatch = lower.match(/(\d+)\s*month/i);
+  
+  if (lower === 'today') {
+    const d = new Date(now);
+    d.setHours(0, 0, 0, 0);
+    return d;
+  }
+  if (lower === 'yesterday') return new Date(now.getTime() - 86400000);
+  if (lower === 'thisweek' || lower === 'this week') {
+    const d = new Date(now);
+    d.setDate(d.getDate() - d.getDay());
+    d.setHours(0, 0, 0, 0);
+    return d;
+  }
+  if (lower === 'lastweek' || lower === 'last week') {
+    const d = new Date(now);
+    d.setDate(d.getDate() - d.getDay() - 7);
+    return d;
+  }
+  
+  if (dayMatch) return new Date(now.getTime() - parseInt(dayMatch[1]) * 86400000);
+  if (weekMatch) return new Date(now.getTime() - parseInt(weekMatch[1]) * 604800000);
+  if (monthMatch) return new Date(now.getTime() - parseInt(monthMatch[1]) * 2592000000);
+  
+  return null;
+}
+
+export function filterByDateRange<T extends { createdAt?: string | null }>(
+  items: T[], 
+  since?: string, 
+  until?: string
+): T[] {
+  const sinceDate = parseDate(since || '');
+  const untilDate = parseDate(until || '');
+  
+  return items.filter(item => {
+    if (!item.createdAt) return true;
+    const created = new Date(item.createdAt);
+    if (sinceDate && created < sinceDate) return false;
+    if (untilDate && created > untilDate) return false;
+    return true;
+  });
+}

package/core/lib/validation.ts

@@ -0,0 +1,180 @@
+/**
+ * Input validation utilities for Squish
+ * Consolidates scattered validation patterns into a unified module
+ */
+
+import { clampLimit as originalClampLimit } from './utils.js';
+import { normalizeTags } from '../memory/serialization.js';
+
+/**
+ * Validate and normalize a limit value with bounds checking
+ */
+export function validateLimit(
+  value: number | string | undefined,
+  defaultValue: number = 20,
+  min: number = 1,
+  max: number = 100
+): number {
+  // Handle undefined, null, empty string
+  if (value === undefined || value === null || value === '') {
+    return defaultValue;
+  }
+
+  // Convert string to number, truncate decimals
+  let num: number;
+  if (typeof value === 'string') {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed)) {
+      return NaN;
+    }
+    num = parsed;
+  } else {
+    // Truncate decimals for numbers
+    num = Math.trunc(value);
+  }
+
+  // Handle NaN
+  if (isNaN(num)) {
+    return NaN;
+  }
+
+  // Clamp to bounds
+  return Math.min(Math.max(num, min), max);
+}
+
+/**
+ * Parse an integer with bounds checking
+ */
+export function parseIntBounded(
+  value: number | string | undefined,
+  defaultValue: number,
+  min: number,
+  max: number
+): number {
+  return validateLimit(value, defaultValue, min, max);
+}
+
+/**
+ * Validate a project path
+ */
+export async function validateProjectPath(
+  path: string | undefined,
+  options?: { createIfMissing?: boolean; require?: boolean }
+): Promise<string> {
+  const { createIfMissing = false, require: requireProject = false } = options || {};
+
+  // If path is undefined, throw if required or return current directory
+  if (path === undefined || path === '') {
+    if (requireProject) {
+      throw new Error('Project path is required');
+    }
+    return process.cwd();
+  }
+
+  // Resolve to absolute path
+  const absolutePath = path.startsWith('/') || /^[a-zA-Z]:\\/.test(path)
+    ? path
+    : path.startsWith('~')
+    ? path.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '')
+    : path.startsWith('.')
+    ? path
+    : path;
+
+  // Check if project exists in database
+  const { getProjectByPath } = await import('../projects.js');
+  const existingProject = await getProjectByPath(absolutePath);
+
+  if (existingProject) {
+    return absolutePath;
+  }
+
+  // Project doesn't exist
+  if (requireProject) {
+    throw new Error(`Project not found: ${absolutePath}`);
+  }
+
+  if (createIfMissing) {
+    const { ensureProject } = await import('../projects.js');
+    await ensureProject(absolutePath);
+    return absolutePath;
+  }
+
+  // Return the path even if it doesn't exist in database (for non-db validation)
+  return absolutePath;
+}
+
+/**
+ * Validate a UUID
+ */
+export function validateUuid(id: string): boolean {
+  if (typeof id !== 'string' || !id) {
+    return false;
+  }
+
+  // UUID v4/v5 regex pattern (8-4-4-4-12 hex digits)
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(id);
+}
+
+/**
+ * Require a valid UUID, throws if invalid
+ */
+export function requireUuid(id: string): string {
+  if (!validateUuid(id)) {
+    throw new Error('Invalid UUID');
+  }
+  return id;
+}
+
+/**
+ * Validate a date value
+ *
+ * @param value - The date to validate (string, Date, number, or undefined)
+ * @returns Date object if valid, null otherwise
+ */
+export function validateDate(value: string | Date | number | undefined): Date | null {
+  if (!value) {
+    return null;
+  }
+
+  try {
+    let date: Date;
+
+    if (value instanceof Date) {
+      date = value;
+    } else if (typeof value === 'number') {
+      // Handle both milliseconds and seconds timestamps
+      if (value > 100000000000000) {
+        // Microseconds, convert to milliseconds
+        date = new Date(value / 1000);
+      } else if (value > 1000000000000) {
+        // Milliseconds
+        date = new Date(value);
+      } else if (value >= 0) {
+        // Seconds
+        date = new Date(value * 1000);
+      } else {
+        return null;
+      }
+    } else if (typeof value === 'string') {
+      date = new Date(value);
+    } else {
+      return null;
+    }
+
+    // Check if date is valid
+    if (isNaN(date.getTime())) {
+      return null;
+    }
+
+    return date;
+  } catch {
+    return null;
+  }
+}
+
+// Re-export normalizeTags for tag validation
+export { normalizeTags };
+
+// Re-export clampLimit for backward compatibility
+export { clampLimit } from './utils.js';