@twelvehart/supermemory-runtime 1.0.0-next.0

package/scripts/run-phase1-tests.sh

@@ -0,0 +1,291 @@
+#!/bin/bash
+# Phase 1 Database Triggers & Functions Test Runner
+# TASK-003 Test Execution Script
+# Created: 2026-02-02
+
+set -e  # Exit on error
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+DB_NAME="${DB_NAME:-supermemory_test}"
+DB_USER="${DB_USER:-postgres}"
+DB_HOST="${DB_HOST:-localhost}"
+DB_PORT="${DB_PORT:-5432}"
+TEST_FILE="tests/database/phase1-triggers-functions.test.sql"
+LOG_FILE="test_output.log"
+
+# Function to print colored output
+print_header() {
+    echo -e "${BLUE}========================================${NC}"
+    echo -e "${BLUE}$1${NC}"
+    echo -e "${BLUE}========================================${NC}"
+}
+
+print_success() {
+    echo -e "${GREEN}✅ $1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}❌ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠️  $1${NC}"
+}
+
+print_info() {
+    echo -e "${BLUE}ℹ️  $1${NC}"
+}
+
+# Function to check if PostgreSQL is running
+check_postgres() {
+    print_header "Checking PostgreSQL Connection"
+
+    if ! command -v psql &> /dev/null; then
+        print_error "psql not found. Please install PostgreSQL client."
+        exit 1
+    fi
+
+    if ! psql -h $DB_HOST -p $DB_PORT -U $DB_USER -lqt &> /dev/null; then
+        print_error "Cannot connect to PostgreSQL at $DB_HOST:$DB_PORT"
+        print_info "Make sure PostgreSQL is running and credentials are correct"
+        exit 1
+    fi
+
+    print_success "PostgreSQL connection verified"
+}
+
+# Function to check if pgvector is installed
+check_pgvector() {
+    print_header "Checking pgvector Extension"
+
+    # Check if extension is available
+    if ! psql -h $DB_HOST -p $DB_PORT -U $DB_USER -d postgres -tAc "SELECT 1 FROM pg_available_extensions WHERE name='vector'" | grep -q 1; then
+        print_error "pgvector extension not available"
+        print_info "Install pgvector: https://github.com/pgvector/pgvector"
+        exit 1
+    fi
+
+    print_success "pgvector extension available"
+}
+
+# Function to create test database
+create_test_db() {
+    print_header "Setting Up Test Database"
+
+    # Drop existing test database if it exists
+    if psql -h $DB_HOST -p $DB_PORT -U $DB_USER -lqt | cut -d \| -f 1 | grep -qw $DB_NAME; then
+        print_warning "Test database '$DB_NAME' already exists. Dropping it..."
+        dropdb -h $DB_HOST -p $DB_PORT -U $DB_USER $DB_NAME
+    fi
+
+    # Create fresh test database
+    print_info "Creating test database '$DB_NAME'..."
+    createdb -h $DB_HOST -p $DB_PORT -U $DB_USER $DB_NAME
+
+    # Enable pgvector extension
+    print_info "Enabling pgvector extension..."
+    psql -h $DB_HOST -p $DB_PORT -U $DB_USER -d $DB_NAME -c "CREATE EXTENSION vector;" > /dev/null
+
+    print_success "Test database created and configured"
+}
+
+# Function to run migrations
+run_migrations() {
+    print_header "Running Database Migrations"
+
+    MIGRATION_DIR="scripts/migrations"
+
+    if [ ! -d "$MIGRATION_DIR" ]; then
+        print_warning "Migration directory not found. Skipping migrations."
+        return
+    fi
+
+    # Run migrations in order
+    for migration in $(ls $MIGRATION_DIR/*.sql 2>/dev/null | sort); do
+        # Skip test files
+        if [[ $migration == *"test_"* ]]; then
+            continue
+        fi
+
+        print_info "Running migration: $(basename $migration)"
+        psql -h $DB_HOST -p $DB_PORT -U $DB_USER -d $DB_NAME -f "$migration" > /dev/null 2>&1 || {
+            print_warning "Migration $(basename $migration) failed or already applied"
+        }
+    done
+
+    print_success "Migrations completed"
+}
+
+# Function to run test suite
+run_tests() {
+    print_header "Running Phase 1 Test Suite"
+
+    if [ ! -f "$TEST_FILE" ]; then
+        print_error "Test file not found: $TEST_FILE"
+        exit 1
+    fi
+
+    print_info "Executing tests from $TEST_FILE"
+    print_info "Output will be saved to $LOG_FILE"
+
+    # Run tests and capture output
+    if psql -h $DB_HOST -p $DB_PORT -U $DB_USER -d $DB_NAME -f "$TEST_FILE" > "$LOG_FILE" 2>&1; then
+        print_success "Test execution completed"
+    else
+        print_error "Test execution failed"
+        return 1
+    fi
+}
+
+# Function to analyze test results
+analyze_results() {
+    print_header "Analyzing Test Results"
+
+    if [ ! -f "$LOG_FILE" ]; then
+        print_error "Log file not found: $LOG_FILE"
+        exit 1
+    fi
+
+    # Count test results
+    PASSED=$(grep -c "TEST PASSED" "$LOG_FILE" 2>/dev/null || echo 0)
+    FAILED=$(grep -c "TEST FAILED" "$LOG_FILE" 2>/dev/null || echo 0)
+    WARNINGS=$(grep -c "PERFORMANCE WARNING" "$LOG_FILE" 2>/dev/null || echo 0)
+
+    echo ""
+    echo "Test Summary:"
+    echo "============="
+    print_success "Passed: $PASSED"
+
+    if [ $FAILED -gt 0 ]; then
+        print_error "Failed: $FAILED"
+    else
+        print_info "Failed: $FAILED"
+    fi
+
+    if [ $WARNINGS -gt 0 ]; then
+        print_warning "Warnings: $WARNINGS"
+    fi
+
+    # Show performance metrics
+    echo ""
+    echo "Performance Metrics:"
+    echo "==================="
+    grep "PERFORMANCE:" "$LOG_FILE" | while read line; do
+        print_info "$line"
+    done
+
+    # Show failures if any
+    if [ $FAILED -gt 0 ]; then
+        echo ""
+        print_error "Failed Tests:"
+        grep "TEST FAILED" "$LOG_FILE"
+        return 1
+    fi
+
+    echo ""
+    print_success "All tests passed! 🎉"
+    return 0
+}
+
+# Function to show detailed logs
+show_logs() {
+    print_header "Detailed Test Output"
+    cat "$LOG_FILE"
+}
+
+# Function to cleanup
+cleanup() {
+    print_header "Cleanup"
+
+    if [ "$KEEP_DB" = "true" ]; then
+        print_info "Keeping test database (KEEP_DB=true)"
+        print_info "To clean up later: dropdb $DB_NAME"
+    else
+        print_info "Dropping test database..."
+        dropdb -h $DB_HOST -p $DB_PORT -U $DB_USER $DB_NAME 2>/dev/null || true
+        print_success "Test database dropped"
+    fi
+
+    if [ -f "$LOG_FILE" ]; then
+        print_info "Test log saved to: $LOG_FILE"
+    fi
+}
+
+# Main execution
+main() {
+    print_header "Phase 1 Database Test Suite"
+    echo "Test Database: $DB_NAME"
+    echo "PostgreSQL: $DB_USER@$DB_HOST:$DB_PORT"
+    echo ""
+
+    # Run all steps
+    check_postgres
+    check_pgvector
+    create_test_db
+    run_migrations
+    run_tests
+
+    # Analyze results
+    if analyze_results; then
+        EXIT_CODE=0
+    else
+        EXIT_CODE=1
+    fi
+
+    # Optional: show detailed logs
+    if [ "$VERBOSE" = "true" ]; then
+        show_logs
+    fi
+
+    # Cleanup
+    cleanup
+
+    exit $EXIT_CODE
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --keep-db)
+            KEEP_DB=true
+            shift
+            ;;
+        --verbose)
+            VERBOSE=true
+            shift
+            ;;
+        --help)
+            echo "Usage: $0 [OPTIONS]"
+            echo ""
+            echo "Options:"
+            echo "  --keep-db    Keep test database after tests complete"
+            echo "  --verbose    Show detailed test output"
+            echo "  --help       Show this help message"
+            echo ""
+            echo "Environment Variables:"
+            echo "  DB_NAME      Test database name (default: supermemory_test)"
+            echo "  DB_USER      PostgreSQL user (default: postgres)"
+            echo "  DB_HOST      PostgreSQL host (default: localhost)"
+            echo "  DB_PORT      PostgreSQL port (default: 5432)"
+            echo ""
+            echo "Example:"
+            echo "  DB_NAME=mytest $0 --keep-db --verbose"
+            exit 0
+            ;;
+        *)
+            print_error "Unknown option: $1"
+            echo "Use --help for usage information"
+            exit 1
+            ;;
+    esac
+done
+
+# Run main
+main

package/scripts/setup.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env tsx
+import { createInterface } from 'node:readline/promises';
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { resolveEnvFile } from '../src/config/env.js';
+
+type Answers = {
+  databaseUrl: string;
+  authEnabled: boolean;
+  authToken: string;
+  redisUrl: string;
+  llmProvider: '' | 'openai' | 'anthropic';
+  openaiApiKey: string;
+  anthropicApiKey: string;
+};
+
+const DEFAULT_DATABASE_URL = 'postgresql://supermemory:supermemory_secret@localhost:15432/supermemory';
+const DEFAULT_REDIS_URL = 'redis://localhost:16379';
+
+function parseEnv(raw: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx <= 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    env[key] = value;
+  }
+  return env;
+}
+
+function parseArgs(): { envFile?: string } {
+  const args = process.argv.slice(2);
+  let envFile: string | undefined;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--env-file') {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error('--env-file requires a value');
+      }
+      envFile = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--env-file=')) {
+      envFile = arg.slice('--env-file='.length);
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return { envFile };
+}
+
+async function questionWithDefault(
+  rl: ReturnType<typeof createInterface>,
+  prompt: string,
+  fallback: string
+): Promise<string> {
+  const answer = (await rl.question(`${prompt} [${fallback}]: `)).trim();
+  return answer || fallback;
+}
+
+async function askYesNo(
+  rl: ReturnType<typeof createInterface>,
+  prompt: string,
+  fallback: boolean
+): Promise<boolean> {
+  const label = fallback ? 'Y/n' : 'y/N';
+  const answer = (await rl.question(`${prompt} (${label}): `)).trim().toLowerCase();
+  if (!answer) return fallback;
+  return answer === 'y' || answer === 'yes';
+}
+
+async function run(): Promise<void> {
+  const { envFile } = parseArgs();
+  const envResolution = resolveEnvFile({ cliEnvFile: envFile });
+  const existingEnv = envResolution.exists ? parseEnv(await readFile(envResolution.path, 'utf-8')) : {};
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('\nSupermemory setup configurator\n');
+  console.log('Press Enter to accept defaults.\n');
+
+  const useDefaultDb = await askYesNo(
+    rl,
+    'Use local Docker/Postgres default connection string?',
+    true
+  );
+  const databaseUrl = useDefaultDb
+    ? DEFAULT_DATABASE_URL
+    : await questionWithDefault(
+        rl,
+        'DATABASE_URL',
+        existingEnv.DATABASE_URL || DEFAULT_DATABASE_URL
+      );
+
+  const authEnabled = await askYesNo(
+    rl,
+    'Enable bearer-token auth for REST API?',
+    (existingEnv.AUTH_ENABLED || 'false') === 'true'
+  );
+  const authToken = authEnabled
+    ? await questionWithDefault(
+        rl,
+        'AUTH_TOKEN',
+        existingEnv.AUTH_TOKEN || randomBytes(24).toString('base64url')
+      )
+    : '';
+
+  const useRedis = await askYesNo(
+    rl,
+    'Use Redis queue workers (recommended for async extraction)?',
+    true
+  );
+  const redisUrl = useRedis
+    ? await questionWithDefault(rl, 'REDIS_URL', existingEnv.REDIS_URL || DEFAULT_REDIS_URL)
+    : '';
+
+  const llmChoice = await questionWithDefault(
+    rl,
+    'LLM provider (none/openai/anthropic)',
+    existingEnv.LLM_PROVIDER || 'none'
+  );
+  const llmProvider: '' | 'openai' | 'anthropic' =
+    llmChoice === 'openai' || llmChoice === 'anthropic' ? llmChoice : '';
+
+  const openaiApiKey =
+    llmProvider === 'openai'
+      ? await questionWithDefault(rl, 'OPENAI_API_KEY', existingEnv.OPENAI_API_KEY || '')
+      : existingEnv.OPENAI_API_KEY || '';
+  const anthropicApiKey =
+    llmProvider === 'anthropic'
+      ? await questionWithDefault(rl, 'ANTHROPIC_API_KEY', existingEnv.ANTHROPIC_API_KEY || '')
+      : existingEnv.ANTHROPIC_API_KEY || '';
+
+  rl.close();
+
+  const answers: Answers = {
+    databaseUrl,
+    authEnabled,
+    authToken,
+    redisUrl,
+    llmProvider,
+    openaiApiKey,
+    anthropicApiKey,
+  };
+
+  if (envResolution.exists) {
+    const backupPath = `${envResolution.path}.backup-${Date.now()}`;
+    await rename(envResolution.path, backupPath);
+    console.log(`Backed up existing env file to ${backupPath}`);
+  }
+
+  const envText = `# Generated by scripts/setup.ts
+DATABASE_URL=${answers.databaseUrl}
+API_HOST=localhost
+API_PORT=13000
+API_HOST_PORT=13000
+
+# Optional REST API auth
+AUTH_ENABLED=${answers.authEnabled ? 'true' : 'false'}
+AUTH_TOKEN=${answers.authToken}
+CSRF_SECRET=${randomBytes(48).toString('base64url')}
+
+# Optional queue workers (if unset, API falls back to inline processing)
+REDIS_URL=${answers.redisUrl}
+POSTGRES_HOST_PORT=15432
+REDIS_HOST_PORT=16379
+BULLMQ_CONCURRENCY_EXTRACTION=5
+BULLMQ_CONCURRENCY_CHUNKING=3
+BULLMQ_CONCURRENCY_EMBEDDING=2
+BULLMQ_CONCURRENCY_INDEXING=1
+
+# Optional LLM extraction provider
+LLM_PROVIDER=${answers.llmProvider}
+OPENAI_API_KEY=${answers.openaiApiKey}
+ANTHROPIC_API_KEY=${answers.anthropicApiKey}
+
+LLM_MODEL=
+LLM_MAX_TOKENS=2000
+LLM_TEMPERATURE=0.1
+LLM_TIMEOUT_MS=30000
+LLM_MAX_RETRIES=3
+LLM_CACHE_ENABLED=true
+LLM_CACHE_TTL_MS=900000
+
+EMBEDDING_MODEL=text-embedding-3-small
+EMBEDDING_DIMENSIONS=1536
+RATE_LIMIT_REQUESTS=100
+RATE_LIMIT_WINDOW_MS=60000
+LOG_LEVEL=info
+`;
+
+  await mkdir(dirname(envResolution.path), { recursive: true });
+  await writeFile(envResolution.path, envText, 'utf-8');
+
+  console.log(`\nWrote env file successfully: ${envResolution.path}\n`);
+  console.log('Next steps:');
+  console.log('1) Start dependencies: docker compose up -d postgres redis');
+  console.log('2) Run migrations: ./scripts/migrations/run_migrations.sh');
+  console.log(`3) Validate config: npm run doctor -- --env-file ${envResolution.path}`);
+  console.log('4) Start API: npm run dev');
+}
+
+run().catch((error) => {
+  console.error('Setup failed:', error);
+  process.exit(1);
+});

package/scripts/smoke-install.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+TARGET_DIR="${1:-./supermemory-smoke}"
+INSTALLER_VERSION="${SUPERMEMORY_INSTALLER_VERSION:-latest}"
+RUNTIME_VERSION="${SUPERMEMORY_RUNTIME_VERSION:-latest}"
+
+npx -y "@twelvehart/supermemory@${INSTALLER_VERSION}" full \
+  --dir "$TARGET_DIR" \
+  --mcp project \
+  --runtime-version "$RUNTIME_VERSION" \
+  --skip-api-keys