@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/development/fix-strict-mode-issues.ts

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix common TypeScript strict mode issues
+ * STA-34: Enable TypeScript Strict Mode
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..');
+
+interface StrictModeIssue {
+  file: string;
+  line: number;
+  column: number;
+  type:
+    | 'possibly_undefined'
+    | 'index_signature'
+    | 'implicit_any'
+    | 'unknown_type';
+  description: string;
+}
+
+class StrictModeFixer {
+  private issues: StrictModeIssue[] = [];
+
+  /**
+   * Fix process.env access issues (noPropertyAccessFromIndexSignature)
+   */
+  async fixProcessEnvAccess(): Promise<void> {
+    console.log('🔧 Fixing process.env access issues...');
+
+    const files = await this.findFilesWithPattern(/process\.env\.\w+/);
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf-8');
+      let updated = content;
+
+      // Replace process.env['VAR'] with process.env['VAR']
+      updated = updated.replace(/process\.env\.(\w+)/g, "process.env['$1']");
+
+      if (updated !== content) {
+        fs.writeFileSync(file, updated);
+        console.log(
+          `✅ Fixed process.env access in ${path.relative(projectRoot, file)}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Fix possibly undefined issues with null assertion or optional chaining
+   */
+  async fixPossiblyUndefined(): Promise<void> {
+    console.log('🔧 Fixing possibly undefined issues...');
+
+    // Common patterns that can be safely fixed
+    const patterns = [
+      {
+        // Fix array access that's known to exist
+        from: /(\w+)\[(\d+)\](?!\?)/g,
+        to: '$1[$2]!',
+        condition: (match: string, file: string) => {
+          // Only apply if it's an array access in test or known safe contexts
+          return file.includes('test') || file.includes('spec');
+        },
+      },
+    ];
+
+    const files = await this.findTypescriptFiles();
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf-8');
+      let updated = content;
+      let hasChanges = false;
+
+      for (const pattern of patterns) {
+        const matches = content.match(pattern.from);
+        if (matches && pattern.condition(content, file)) {
+          updated = updated.replace(pattern.from, pattern.to);
+          hasChanges = true;
+        }
+      }
+
+      if (hasChanges) {
+        fs.writeFileSync(file, updated);
+        console.log(
+          `✅ Fixed undefined issues in ${path.relative(projectRoot, file)}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Fix unknown type issues by adding proper type annotations
+   */
+  async fixUnknownTypes(): Promise<void> {
+    console.log('🔧 Fixing unknown type issues...');
+
+    const files = await this.findTypescriptFiles();
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf-8');
+      let updated = content;
+
+      // Fix catch blocks with unknown error
+      updated = updated.replace(
+        /catch\s*\(\s*(\w+)\s*\)\s*{/g,
+        'catch ($1: unknown) {'
+      );
+
+      // Fix error parameter in catch blocks
+      updated = updated.replace(/(\w+) is of type 'unknown'/g, '$1 as Error');
+
+      if (updated !== content) {
+        fs.writeFileSync(file, updated);
+        console.log(
+          `✅ Fixed unknown types in ${path.relative(projectRoot, file)}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Fix implicit any issues by adding type annotations
+   */
+  async fixImplicitAny(): Promise<void> {
+    console.log('🔧 Fixing implicit any issues...');
+
+    const files = await this.findTypescriptFiles();
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf-8');
+      let updated = content;
+
+      // Fix common implicit any patterns
+      updated = updated.replace(/\.map\(\s*(\w+)\s*=>/g, '.map(($1: any) =>');
+
+      updated = updated.replace(
+        /\.filter\(\s*(\w+)\s*=>/g,
+        '.filter(($1: any) =>'
+      );
+
+      updated = updated.replace(/\.find\(\s*(\w+)\s*=>/g, '.find(($1: any) =>');
+
+      if (updated !== content) {
+        fs.writeFileSync(file, updated);
+        console.log(
+          `✅ Fixed implicit any in ${path.relative(projectRoot, file)}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Add type guards for environment variable access
+   */
+  async addEnvironmentTypeGuards(): Promise<void> {
+    console.log('🔧 Adding environment variable type guards...');
+
+    const files = await this.findFilesWithPattern(/process\.env\[/);
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf-8');
+      let updated = content;
+
+      // Add utility function for safe env access at the top of files that need it
+      if (
+        content.includes("process.env['") &&
+        !content.includes('function getEnv(')
+      ) {
+        const imports = content.match(/^import.*$/gm) || [];
+        const lastImportIndex = content.lastIndexOf(
+          imports[imports.length - 1] || ''
+        );
+
+        const envUtility = `
+// Type-safe environment variable access
+function getEnv(key: string, defaultValue?: string): string {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw new Error(\`Environment variable \${key} is required\`);
+  }
+  return value;
+}
+
+function getOptionalEnv(key: string): string | undefined {
+  return process.env[key];
+}
+`;
+
+        updated =
+          content.slice(
+            0,
+            lastImportIndex + imports[imports.length - 1]?.length || 0
+          ) +
+          envUtility +
+          content.slice(
+            lastImportIndex + imports[imports.length - 1]?.length || 0
+          );
+
+        fs.writeFileSync(file, updated);
+        console.log(
+          `✅ Added env utilities to ${path.relative(projectRoot, file)}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Find all TypeScript files in the project
+   */
+  private async findTypescriptFiles(): Promise<string[]> {
+    const files: string[] = [];
+
+    const walk = (dir: string): void => {
+      const items = fs.readdirSync(dir);
+
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = fs.statSync(fullPath);
+
+        if (
+          stat.isDirectory() &&
+          !item.startsWith('.') &&
+          item !== 'node_modules' &&
+          item !== 'dist'
+        ) {
+          walk(fullPath);
+        } else if (
+          stat.isFile() &&
+          (item.endsWith('.ts') || item.endsWith('.tsx')) &&
+          !item.endsWith('.d.ts')
+        ) {
+          files.push(fullPath);
+        }
+      }
+    };
+
+    walk(path.join(projectRoot, 'src'));
+    walk(path.join(projectRoot, 'scripts'));
+
+    return files;
+  }
+
+  /**
+   * Find files containing a specific pattern
+   */
+  private async findFilesWithPattern(pattern: RegExp): Promise<string[]> {
+    const allFiles = await this.findTypescriptFiles();
+    const matchingFiles: string[] = [];
+
+    for (const file of allFiles) {
+      const content = fs.readFileSync(file, 'utf-8');
+      if (pattern.test(content)) {
+        matchingFiles.push(file);
+      }
+    }
+
+    return matchingFiles;
+  }
+
+  /**
+   * Run all fixes
+   */
+  async runAllFixes(): Promise<void> {
+    console.log('🚀 Starting TypeScript strict mode fixes...\n');
+
+    await this.fixProcessEnvAccess();
+    await this.addEnvironmentTypeGuards();
+    await this.fixUnknownTypes();
+    await this.fixImplicitAny();
+    // await this.fixPossiblyUndefined(); // Skip this for now as it's more complex
+
+    console.log('\n✅ All automated fixes completed!');
+    console.log('\nRemaining issues will need manual review:');
+    console.log('- Complex possibly undefined cases');
+    console.log('- Interface property mismatches');
+    console.log('- Context-specific type assertions');
+
+    console.log('\n🔧 Run `npx tsc --noEmit` to check remaining issues');
+  }
+}
+
+// Run the fixer
+const fixer = new StrictModeFixer();
+fixer.runAllFixes().catch(console.error);

package/scripts/development/reorganize-structure.sh

@@ -0,0 +1,228 @@
+#!/bin/bash
+
+# StackMemory Folder Structure Reorganization Script
+# This script reorganizes the codebase to the new structure
+
+set -e
+
+echo "🔄 Starting StackMemory folder reorganization..."
+
+# Create new directory structure
+echo "📁 Creating new directory structure..."
+
+# Core directories
+mkdir -p src/core/{context,projects,storage,monitoring,utils}
+mkdir -p src/core/storage/{migrations,repositories}
+
+# Features directories
+mkdir -p src/features/{analytics,tasks,browser}
+
+# Integrations directories
+mkdir -p src/integrations/{linear,github,mcp}
+
+# CLI directories
+mkdir -p src/cli/commands
+mkdir -p src/cli/utils
+
+# Servers directories
+mkdir -p src/servers/{local,railway,production}
+
+# Scripts directories
+mkdir -p scripts/{setup,deployment,development,hooks}
+
+# Config directories
+mkdir -p config/{docker,environments}
+
+# Tests directories
+mkdir -p tests/{unit,integration,e2e}
+
+# Docs directories
+mkdir -p docs/{architecture,guides,api,releases}
+
+echo "📦 Moving core files..."
+
+# Move core context files
+if [ -f "src/core/frame-manager.ts" ]; then
+  mv src/core/frame-manager.ts src/core/context/frame-manager.ts
+fi
+
+# Move project management files
+if [ -f "src/core/project-manager.ts" ]; then
+  mv src/core/project-manager.ts src/core/projects/project-manager.ts
+fi
+
+# Move monitoring files
+if [ -f "src/core/logger.ts" ]; then
+  mv src/core/logger.ts src/core/monitoring/logger.ts
+fi
+if [ -f "src/core/error-handler.ts" ]; then
+  mv src/core/error-handler.ts src/core/monitoring/error-handler.ts
+fi
+if [ -f "src/core/progress-tracker.ts" ]; then
+  mv src/core/progress-tracker.ts src/core/monitoring/progress-tracker.ts
+fi
+
+# Move utils
+if [ -f "src/core/update-checker.ts" ]; then
+  mv src/core/update-checker.ts src/core/utils/update-checker.ts
+fi
+
+echo "✨ Moving features..."
+
+# Move analytics to features
+if [ -d "src/analytics" ]; then
+  mv src/analytics/* src/features/analytics/ 2>/dev/null || true
+  rmdir src/analytics 2>/dev/null || true
+fi
+
+# Move pebbles to tasks feature
+if [ -d "src/pebbles" ]; then
+  mv src/pebbles/* src/features/tasks/ 2>/dev/null || true
+  rmdir src/pebbles 2>/dev/null || true
+fi
+
+# Move browser integration
+if [ -f "src/integrations/browser-mcp.ts" ]; then
+  mv src/integrations/browser-mcp.ts src/features/browser/browser-mcp.ts
+fi
+
+echo "🔌 Moving integrations..."
+
+# Move Linear files
+for file in src/integrations/linear-*.ts; do
+  if [ -f "$file" ]; then
+    basename=$(basename "$file" | sed 's/linear-//')
+    mv "$file" "src/integrations/linear/$basename"
+  fi
+done
+
+# Move MCP files
+if [ -f "src/mcp/mcp-server.ts" ]; then
+  mv src/mcp/mcp-server.ts src/integrations/mcp/server.ts
+fi
+if [ -d "src/mcp" ]; then
+  rmdir src/mcp 2>/dev/null || true
+fi
+
+echo "💻 Moving CLI files..."
+
+# Rename main CLI file
+if [ -f "src/cli/cli.ts" ]; then
+  mv src/cli/cli.ts src/cli/index.ts
+fi
+
+# Move CLI commands
+if [ -f "src/cli/project-commands.ts" ]; then
+  mv src/cli/project-commands.ts src/cli/commands/projects.ts
+fi
+if [ -f "src/cli/analytics-viewer.ts" ]; then
+  mv src/cli/analytics-viewer.ts src/cli/utils/viewer.ts
+fi
+
+echo "🚀 Moving server files..."
+
+# Move railway server
+if [ -d "src/railway" ]; then
+  mv src/railway/* src/servers/railway/ 2>/dev/null || true
+  rmdir src/railway 2>/dev/null || true
+fi
+
+# Move production configs from runway.bak
+if [ -d "src/runway.bak" ]; then
+  mv src/runway.bak/auth/* src/servers/production/ 2>/dev/null || true
+  mv src/runway.bak/database/* src/servers/production/ 2>/dev/null || true
+  mv src/runway.bak/monitoring/* src/servers/production/ 2>/dev/null || true
+  rm -rf src/runway.bak
+fi
+
+echo "📝 Moving scripts..."
+
+# Move setup scripts
+if [ -f "scripts/setup-alias.js" ]; then
+  mv scripts/setup-alias.js scripts/setup/configure-alias.js
+fi
+if [ -f "scripts/setup-claude-integration.js" ]; then
+  mv scripts/setup-claude-integration.js scripts/setup/claude-integration.js
+fi
+
+# Move deployment scripts
+if [ -f "scripts/deploy-runway.sh" ]; then
+  mv scripts/deploy-runway.sh scripts/deployment/railway.sh
+fi
+if [ -f "scripts/test-railway.js" ]; then
+  mv scripts/test-railway.js scripts/deployment/test-deployment.js
+fi
+
+# Move development scripts
+if [ -f "scripts/fix-lint-loop.cjs" ]; then
+  mv scripts/fix-lint-loop.cjs scripts/development/fix-lint-loop.cjs
+fi
+
+# Move hook scripts
+if [ -f "scripts/task-complete-hook.sh" ]; then
+  mv scripts/task-complete-hook.sh scripts/hooks/task-complete.sh
+fi
+if [ -f "scripts/cleanup-shell-configs.sh" ]; then
+  mv scripts/cleanup-shell-configs.sh scripts/hooks/cleanup-shell.sh
+fi
+
+echo "⚙️ Moving configuration files..."
+
+# Move Docker files
+if [ -f "Dockerfile.runway" ]; then
+  mv Dockerfile.runway config/docker/Dockerfile
+fi
+if [ -f "docker-compose.runway.yml" ]; then
+  mv docker-compose.runway.yml config/docker/docker-compose.yml
+fi
+
+# Move config files
+if [ -f "railway.json" ]; then
+  mv railway.json config/railway.json
+fi
+if [ -f "nixpacks.toml" ]; then
+  mv nixpacks.toml config/nixpacks.toml
+fi
+
+# Move environment files
+if [ -f ".env.railway.example" ]; then
+  mv .env.railway.example config/environments/.env.railway.example
+fi
+
+echo "📚 Moving documentation..."
+
+# Move architecture docs
+if [ -f "docs/MULTI_PROJECT_ARCHITECTURE.md" ]; then
+  mv docs/MULTI_PROJECT_ARCHITECTURE.md docs/architecture/MULTI_PROJECT.md
+fi
+if [ -f "docs/RUNWAY_DEPLOYMENT.md" ]; then
+  mv docs/RUNWAY_DEPLOYMENT.md docs/architecture/DEPLOYMENT.md
+fi
+
+# Move guides
+if [ -f "DEPLOY_RAILWAY.md" ]; then
+  mv DEPLOY_RAILWAY.md docs/guides/RAILWAY_DEPLOY.md
+fi
+
+# Move README files
+if [ -f "README.runway.md" ]; then
+  mv README.runway.md docs/architecture/RUNWAY_README.md
+fi
+
+echo "🧹 Cleaning up empty directories..."
+
+# Remove empty directories
+find src -type d -empty -delete 2>/dev/null || true
+find scripts -type d -empty -delete 2>/dev/null || true
+find docs -type d -empty -delete 2>/dev/null || true
+
+echo "✅ Folder reorganization complete!"
+echo ""
+echo "⚠️ Important next steps:"
+echo "1. Update all import paths in TypeScript files"
+echo "2. Update package.json scripts paths"
+echo "3. Update build configuration"
+echo "4. Run 'npm run build' to verify everything works"
+echo "5. Commit the changes"
+echo ""
+echo "Run 'npm run update-imports' to automatically update import paths (coming next)"

package/scripts/development/test-persistence-direct.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function testDirectPersistence() {
+  console.log('Testing StackMemory Direct Persistence...\n');
+  
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  const contextDir = path.join(homeDir, '.stackmemory', 'shared-context', 'projects');
+  
+  // Ensure directory exists
+  await fs.mkdir(contextDir, { recursive: true });
+  console.log(`✅ Context directory ensured: ${contextDir}`);
+  
+  // Create test context
+  const testContext = {
+    projectId: 'test-persistence',
+    branch: 'main',
+    lastUpdated: Date.now(),
+    sessions: [
+      {
+        sessionId: 'test-session-1',
+        runId: 'test-run-1',
+        summary: 'Test session for persistence verification',
+        keyFrames: [
+          {
+            frameId: 'frame-1',
+            title: 'Test Frame 1',
+            type: 'observation',
+            score: 0.9,
+            tags: ['test', 'persistence'],
+            summary: 'This is a test frame',
+            createdAt: Date.now()
+          },
+          {
+            frameId: 'frame-2',
+            title: 'Error Frame',
+            type: 'error',
+            score: 0.8,
+            tags: ['error', 'test'],
+            summary: 'Test error with resolution',
+            createdAt: Date.now()
+          }
+        ],
+        createdAt: Date.now() - 3600000, // 1 hour ago
+        lastActiveAt: Date.now(),
+        metadata: { test: true }
+      }
+    ],
+    globalPatterns: [
+      {
+        pattern: 'Test error pattern',
+        type: 'error',
+        frequency: 2,
+        lastSeen: Date.now(),
+        resolution: 'Test resolution'
+      }
+    ],
+    decisionLog: [
+      {
+        id: 'decision-1',
+        timestamp: Date.now(),
+        sessionId: 'test-session-1',
+        decision: 'Use persistence layer',
+        rationale: 'For context continuity',
+        outcome: 'success'
+      }
+    ],
+    referenceIndex: {
+      byTag: {},
+      byType: {},
+      recentlyAccessed: ['frame-1', 'frame-2']
+    }
+  };
+  
+  // Save context
+  const contextFile = path.join(contextDir, `${testContext.projectId}_${testContext.branch}.json`);
+  await fs.writeFile(contextFile, JSON.stringify(testContext, null, 2));
+  console.log(`✅ Test context saved to: ${contextFile}`);
+  
+  // Verify it was saved
+  const savedData = await fs.readFile(contextFile, 'utf-8');
+  const savedContext = JSON.parse(savedData);
+  
+  console.log('\n📊 Saved Context Summary:');
+  console.log(`  Sessions: ${savedContext.sessions.length}`);
+  console.log(`  Key frames: ${savedContext.sessions[0].keyFrames.length}`);
+  console.log(`  Global patterns: ${savedContext.globalPatterns.length}`);
+  console.log(`  Decisions: ${savedContext.decisionLog.length}`);
+  
+  // Test that hooks can read this data
+  console.log('\n🔍 Testing Hook Integration...');
+  
+  // Simulate what on-clear hook would do
+  const clearSurvivalFrame = {
+    frameId: 'clear-survival-' + Date.now(),
+    title: 'Context preserved from /clear',
+    type: 'clear_survival',
+    score: 1.0,
+    tags: ['preserved', 'clear_survival'],
+    summary: 'Important context preserved across clear',
+    createdAt: Date.now()
+  };
+  
+  // Add to existing session
+  savedContext.sessions[0].keyFrames.push(clearSurvivalFrame);
+  savedContext.lastUpdated = Date.now();
+  
+  // Save updated context
+  await fs.writeFile(contextFile, JSON.stringify(savedContext, null, 2));
+  console.log('✅ Added clear_survival frame (simulating on-clear hook)');
+  
+  // Verify the update
+  const updatedData = await fs.readFile(contextFile, 'utf-8');
+  const updatedContext = JSON.parse(updatedData);
+  
+  const hasClearSurvival = updatedContext.sessions[0].keyFrames.some(
+    f => f.tags?.includes('clear_survival')
+  );
+  
+  if (hasClearSurvival) {
+    console.log('✅ Clear survival frame persisted successfully!');
+  } else {
+    console.log('❌ Clear survival frame not found');
+  }
+  
+  console.log('\n🎉 Direct persistence test completed!');
+  console.log('\nTo verify manually:');
+  console.log(`  cat ${contextFile} | jq '.sessions[0].keyFrames | length'`);
+  console.log(`  cat ${contextFile} | jq '.sessions[0].keyFrames[] | select(.tags | contains(["clear_survival"]))'`);
+  console.log(`  cat ${contextFile} | jq '.globalPatterns'`);
+  
+  // List all context files
+  console.log('\n📁 All context files:');
+  const files = await fs.readdir(contextDir);
+  for (const file of files) {
+    if (file.endsWith('.json')) {
+      const stats = await fs.stat(path.join(contextDir, file));
+      console.log(`  ${file} (${stats.size} bytes, modified: ${new Date(stats.mtime).toLocaleString()})`);
+    }
+  }
+}
+
+testDirectPersistence().catch(console.error);