@stackmemoryai/stackmemory 0.5.64 → 0.5.66

package/scripts/demos/ralph-integration-demo.ts

@@ -5,7 +5,6 @@
  */
 
 import { RalphStackMemoryBridge } from './bridge/ralph-stackmemory-bridge.js';
-import { logger } from '../../core/monitoring/logger.js';
 import { RalphStackMemoryConfig } from './types.js';
 
 class RalphIntegrationDemo {
@@ -60,9 +59,12 @@ class RalphIntegrationDemo {
       await this.demonstrateMetrics();
 
       console.log('\n✅ Demo completed successfully!\n');
-    } catch (error: any) {
-      console.error('\n❌ Demo failed:', error.message);
-      throw error;
+    } catch (err: unknown) {
+      console.error(
+        '\n❌ Demo failed:',
+        err instanceof Error ? err.message : err
+      );
+      throw err;
     } finally {
       await this.cleanup();
     }
@@ -158,9 +160,6 @@ class RalphIntegrationDemo {
     console.log('\n🚑 Phase 3: Crash Recovery');
     console.log('===========================');
 
-    // Simulate getting session ID
-    const sessionId = 'demo-session-123';
-
     try {
       console.log('🔄 Simulating session rehydration...');
 
@@ -177,8 +176,10 @@ class RalphIntegrationDemo {
       console.log('  - State reconciled: 0.3s');
       console.log('  - Memory usage: 45MB');
       console.log('  - Cache hit rate: 78%');
-    } catch (error: any) {
-      console.log(`⚠️  Recovery simulation: ${error.message}`);
+    } catch (err: unknown) {
+      console.log(
+        `⚠️  Recovery simulation: ${err instanceof Error ? err.message : err}`
+      );
     }
   }
 
@@ -227,10 +228,10 @@ async function main() {
 
   try {
     await demo.run();
-  } catch (error: any) {
-    console.error('Demo failed:', error.message);
-    if (process.env.DEBUG) {
-      console.error(error.stack);
+  } catch (err: unknown) {
+    console.error('Demo failed:', err instanceof Error ? err.message : err);
+    if (process.env.DEBUG && err instanceof Error) {
+      console.error(err.stack);
     }
     process.exit(1);
   }

package/scripts/demos/trace-demo.ts

@@ -6,33 +6,17 @@
 
 import {
   trace,
-  Trace,
-  TraceClass,
   enableVerboseTracing,
   createTracedDatabase,
   traceStep,
 } from './index.js';
-import { logger } from '../monitoring/logger.js';
-// 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];
-}
 
 // Example class with tracing
 // @TraceClass() - decorators not enabled in tsconfig
 class ExampleService {
-  private data: Map<string, any> = new Map();
+  private data: Map<string, unknown> = new Map();
 
-  async fetchData(id: string): Promise<any> {
+  async fetchData(id: string): Promise<Record<string, unknown>> {
     // Simulate API call
     await this.delay(50);
 
@@ -43,7 +27,9 @@ class ExampleService {
     return { id, value: Math.random() };
   }
 
-  async processData(data: any): Promise<any> {
+  async processData(
+    data: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
     return traceStep('Data validation', async () => {
       await this.delay(20);
 
@@ -62,7 +48,7 @@ class ExampleService {
     });
   }
 
-  cacheData(key: string, value: any): void {
+  cacheData(key: string, value: unknown): void {
     trace.traceSync('function', 'cacheData', { key, value }, () => {
       this.data.set(key, value);
     });
@@ -161,7 +147,7 @@ async function runDemo() {
 
       try {
         await service.fetchData('error');
-      } catch (error: unknown) {
+      } catch {
         console.log('Error properly traced and handled\n');
       }
     });

package/scripts/demos/trace-test.ts

@@ -3,19 +3,31 @@
  */
 
 import LocalStackMemoryMCP from './server';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+// Type for accessing private members in tests
+interface MCPTestInstance {
+  traceDetector: {
+    addToolCall: (call: {
+      id: string;
+      tool: string;
+      timestamp: number;
+      arguments: Record<string, unknown>;
+    }) => void;
+    flush: () => void;
+  };
+  handleGetTraceStatistics: (
+    args: Record<string, unknown>
+  ) => Promise<{ content: Array<{ text: string }> }>;
+  handleGetTraces: (args: {
+    limit: number;
+  }) => Promise<{ content: Array<{ text: string }> }>;
+}
 
 async function testTraceIntegration() {
   console.log('🧪 Testing Trace Detection in MCP Server\n');
 
-  // Mock minimal server setup
-  const mockServer = {
-    setRequestHandler: () => {},
-    connect: () => Promise.resolve(),
-  } as any;
-
   // Access the private methods through prototype
-  const MCPClass = LocalStackMemoryMCP as any;
+  const MCPClass = LocalStackMemoryMCP as unknown as new () => MCPTestInstance;
   const mcp = new MCPClass();
 
   // Simulate tool calls directly on the trace detector

package/scripts/verify-dist.cjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// Verifies expected dist artifacts and bin launchers point to correct paths.
+// Exits non-zero with actionable messages on mismatch.
+
+const { readFileSync, existsSync } = require('fs');
+const { join } = require('path');
+
+function fail(msg) {
+  console.error(`ERROR: ${msg}`);
+  process.exitCode = 1;
+}
+
+function checkFile(path) {
+  if (!existsSync(path)) {
+    fail(`Missing built file: ${path}`);
+    return false;
+  }
+  return true;
+}
+
+function fileContains(path, substr) {
+  try {
+    const c = readFileSync(path, 'utf8');
+    if (!c.includes(substr)) {
+      fail(`Expected reference not found in ${path}: ${substr}`);
+      return false;
+    }
+    return true;
+  } catch (e) {
+    fail(`Unable to read ${path}: ${e.message}`);
+    return false;
+  }
+}
+
+function main() {
+  const dist = 'dist/src';
+
+  // 1) Core CLI and MCP server artifacts
+  const requiredFiles = [
+    join(dist, 'integrations/mcp/server.js'),
+    join(dist, 'cli/index.js'),
+    join(dist, 'cli/codex-sm.js'),
+    join(dist, 'cli/codex-sm-danger.js'),
+    join(dist, 'cli/claude-sm.js'),
+    join(dist, 'cli/claude-sm-danger.js'),
+  ];
+  requiredFiles.forEach(checkFile);
+
+  // 2) Bin launchers reference dist/src/* (ESM dynamic import)
+  fileContains('bin/codex-sm', "import('../dist/src/cli/codex-sm.js')");
+  fileContains('bin/codex-smd', "import('../dist/src/cli/codex-sm-danger.js')");
+  fileContains('bin/claude-sm', "import('../dist/src/cli/claude-sm.js')");
+  fileContains('bin/claude-smd', "import('../dist/src/cli/claude-sm-danger.js')");
+
+  // 3) package.json scripts point to correct paths
+  try {
+    const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+    const scripts = pkg.scripts || {};
+    const expectations = [
+      ['start', 'dist/src/integrations/mcp/server.js'],
+      ['start:full', 'dist/src/integrations/mcp/server.js'],
+      ['mcp:start', 'dist/src/integrations/mcp/server.js'],
+    ];
+    for (const [key, needle] of expectations) {
+      const val = scripts[key] || '';
+      if (!val.includes(needle)) {
+        fail(`scripts.${key} should reference ${needle}, found: ${val}`);
+      }
+    }
+  } catch (e) {
+    fail(`Failed to validate package.json scripts: ${e.message}`);
+  }
+
+  if (process.exitCode) {
+    console.error('\nOne or more checks failed. Run: npm run build');
+    console.error('Then re-run: npm run verify:dist');
+  } else {
+    console.log('verify-dist: OK');
+  }
+}
+
+main();
+