@stackmemoryai/stackmemory 0.3.17 → 0.3.19

package/scripts/testing/src/core/trace/index.js

@@ -0,0 +1,120 @@
+/**
+ * Trace Module Export
+ * Central export for all tracing functionality
+ */
+export { trace, TraceContext, Trace, TraceClass, TraceCritical, } from './debug-trace.js';
+export { wrapCommand, wrapProgram, traceStep, traceQuery, traceAPI, } from './cli-trace-wrapper.js';
+export { createTracedDatabase, wrapDatabase, getQueryStatistics, createTracedTransaction, } from './db-trace-wrapper.js';
+export { TraceLinearAPI, createTracedFetch, wrapGraphQLClient, } from './linear-api-wrapper.js';
+/**
+ * Initialize tracing based on environment configuration
+ */
+export function initializeTracing() {
+    const config = {
+        // Main control
+        DEBUG_TRACE: process.env.DEBUG_TRACE === 'true',
+        STACKMEMORY_DEBUG: process.env.STACKMEMORY_DEBUG === 'true',
+        // Output control
+        TRACE_OUTPUT: process.env.TRACE_OUTPUT || 'console', // console|file|both
+        TRACE_VERBOSITY: process.env.TRACE_VERBOSITY || 'full', // full|errors|summary
+        // Content control
+        TRACE_PARAMS: process.env.TRACE_PARAMS !== 'false', // Include parameters
+        TRACE_RESULTS: process.env.TRACE_RESULTS !== 'false', // Include results
+        TRACE_MASK_SENSITIVE: process.env.TRACE_MASK_SENSITIVE !== 'false', // Mask sensitive data
+        // Performance
+        TRACE_PERF_THRESHOLD: parseInt(process.env.TRACE_PERF_THRESHOLD || '100'), // ms
+        TRACE_MEMORY: process.env.TRACE_MEMORY === 'true', // Track memory usage
+        TRACE_MAX_DEPTH: parseInt(process.env.TRACE_MAX_DEPTH || '20'), // Max call depth
+        // Database specific
+        TRACE_DB: process.env.TRACE_DB === 'true', // Enable database tracing
+        TRACE_DB_SLOW: parseInt(process.env.TRACE_DB_SLOW || '100'), // Slow query threshold
+        // API specific
+        TRACE_API: process.env.TRACE_API === 'true', // Enable API tracing
+        TRACE_API_SLOW: parseInt(process.env.TRACE_API_SLOW || '1000'), // Slow API threshold
+    };
+    // Log configuration if debugging is enabled
+    if (config.DEBUG_TRACE || config.STACKMEMORY_DEBUG) {
+        console.log('🔍 Trace Configuration:', {
+            enabled: true,
+            output: config.TRACE_OUTPUT,
+            verbosity: config.TRACE_VERBOSITY,
+            includeParams: config.TRACE_PARAMS,
+            includeResults: config.TRACE_RESULTS,
+            maskSensitive: config.TRACE_MASK_SENSITIVE,
+            performanceThreshold: config.TRACE_PERF_THRESHOLD,
+            captureMemory: config.TRACE_MEMORY,
+            maxDepth: config.TRACE_MAX_DEPTH,
+            database: {
+                enabled: config.TRACE_DB,
+                slowThreshold: config.TRACE_DB_SLOW,
+            },
+            api: {
+                enabled: config.TRACE_API,
+                slowThreshold: config.TRACE_API_SLOW,
+            },
+        });
+    }
+}
+/**
+ * Helper to enable tracing for a specific scope
+ */
+export function withTracing(fn, options) {
+    const originalEnv = process.env.DEBUG_TRACE;
+    try {
+        // Temporarily enable tracing
+        process.env.DEBUG_TRACE = 'true';
+        // Apply custom options if provided
+        if (options) {
+            if (options.output)
+                process.env.TRACE_OUTPUT = options.output;
+            if (options.verbosity)
+                process.env.TRACE_VERBOSITY = options.verbosity;
+            if (options.includeParams !== undefined) {
+                process.env.TRACE_PARAMS = String(options.includeParams);
+            }
+            if (options.includeResults !== undefined) {
+                process.env.TRACE_RESULTS = String(options.includeResults);
+            }
+            if (options.performanceThreshold !== undefined) {
+                process.env.TRACE_PERF_THRESHOLD = String(options.performanceThreshold);
+            }
+        }
+        return fn();
+    }
+    finally {
+        // Restore original environment
+        if (originalEnv === undefined) {
+            delete process.env.DEBUG_TRACE;
+        }
+        else {
+            process.env.DEBUG_TRACE = originalEnv;
+        }
+    }
+}
+/**
+ * Quick enable/disable functions for debugging
+ */
+export const enableTracing = () => {
+    process.env.DEBUG_TRACE = 'true';
+    console.log('✅ Tracing enabled');
+};
+export const disableTracing = () => {
+    delete process.env.DEBUG_TRACE;
+    console.log('❌ Tracing disabled');
+};
+export const enableVerboseTracing = () => {
+    process.env.DEBUG_TRACE = 'true';
+    process.env.TRACE_VERBOSITY = 'full';
+    process.env.TRACE_PARAMS = 'true';
+    process.env.TRACE_RESULTS = 'true';
+    process.env.TRACE_MEMORY = 'true';
+    console.log('✅ Verbose tracing enabled');
+};
+export const enableMinimalTracing = () => {
+    process.env.DEBUG_TRACE = 'true';
+    process.env.TRACE_VERBOSITY = 'summary';
+    process.env.TRACE_PARAMS = 'false';
+    process.env.TRACE_RESULTS = 'false';
+    process.env.TRACE_MEMORY = 'false';
+    console.log('✅ Minimal tracing enabled');
+};

package/scripts/testing/src/core/trace/linear-api-wrapper.js

@@ -0,0 +1,204 @@
+/**
+ * Linear API Trace Wrapper
+ * Wraps Linear API client with comprehensive tracing for debugging
+ */
+import { trace } from './debug-trace.js';
+import { logger } from '../monitoring/logger.js';
+/**
+ * Decorator to trace Linear API GraphQL calls
+ */
+export function TraceLinearAPI(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const isAsync = originalMethod.constructor.name === 'AsyncFunction';
+    if (isAsync) {
+        descriptor.value = async function (...args) {
+            const className = target.constructor.name;
+            const methodName = `${className}.${propertyKey}`;
+            // Extract meaningful context from arguments
+            const context = extractAPIContext(propertyKey, args);
+            return trace.traceAsync('api', methodName, context, async () => {
+                const startTime = Date.now();
+                try {
+                    // Log API call start
+                    logger.debug(`Linear API Call: ${methodName}`, context);
+                    const result = await originalMethod.apply(this, args);
+                    const duration = Date.now() - startTime;
+                    // Log successful completion with timing
+                    logger.info(`Linear API Success: ${methodName}`, {
+                        duration,
+                        resultType: Array.isArray(result) ? `array[${result.length}]` : typeof result,
+                        hasData: result != null,
+                    });
+                    // Warn about slow API calls
+                    if (duration > 1000) {
+                        logger.warn(`Slow Linear API call: ${methodName} took ${duration}ms`, {
+                            ...context,
+                            duration,
+                        });
+                    }
+                    return result;
+                }
+                catch (error) {
+                    const duration = Date.now() - startTime;
+                    // Enhanced error logging for API failures
+                    logger.error(`Linear API Failed: ${methodName}`, error, {
+                        ...context,
+                        duration,
+                        errorCode: error.code,
+                        statusCode: error.statusCode,
+                        graphQLErrors: error.errors,
+                    });
+                    // Add debugging hints based on error type
+                    if (error.message?.includes('rate limit')) {
+                        logger.warn('Rate limit hit - consider implementing backoff', {
+                            method: methodName,
+                            suggestion: 'Implement exponential backoff or request queuing',
+                        });
+                    }
+                    else if (error.message?.includes('network')) {
+                        logger.warn('Network error - check connectivity', {
+                            method: methodName,
+                            suggestion: 'Verify API endpoint and network connectivity',
+                        });
+                    }
+                    else if (error.message?.includes('unauthorized')) {
+                        logger.warn('Authorization error - check API key', {
+                            method: methodName,
+                            suggestion: 'Verify LINEAR_API_KEY is set and valid',
+                        });
+                    }
+                    throw error;
+                }
+            });
+        };
+    }
+    else {
+        descriptor.value = function (...args) {
+            const className = target.constructor.name;
+            const methodName = `${className}.${propertyKey}`;
+            const context = extractAPIContext(propertyKey, args);
+            return trace.traceSync('api', methodName, context, () => {
+                return originalMethod.apply(this, args);
+            });
+        };
+    }
+    return descriptor;
+}
+/**
+ * Extract meaningful context from API method arguments
+ */
+function extractAPIContext(methodName, args) {
+    const context = {};
+    // Handle different Linear API methods
+    if (methodName === 'createIssue' && args[0]) {
+        context.title = args[0].title;
+        context.teamId = args[0].teamId;
+        context.priority = args[0].priority;
+    }
+    else if (methodName === 'updateIssue' && args[0]) {
+        context.issueId = args[0];
+        context.updates = Object.keys(args[1] || {});
+    }
+    else if (methodName === 'getIssue') {
+        context.issueId = args[0];
+    }
+    else if (methodName === 'getIssues' && args[0]) {
+        context.filter = args[0];
+    }
+    else if (methodName === 'graphql') {
+        // For raw GraphQL queries
+        const query = args[0];
+        if (query) {
+            // Extract operation name from query
+            const match = query.match(/(?:query|mutation)\s+(\w+)/);
+            context.operation = match ? match[1] : 'unknown';
+            context.queryLength = query.length;
+            context.variables = args[1] ? Object.keys(args[1]) : [];
+        }
+    }
+    return context;
+}
+/**
+ * Wrap fetch with tracing for HTTP-level debugging
+ */
+export function createTracedFetch(baseFetch = fetch) {
+    return async function tracedFetch(input, init) {
+        const url = typeof input === 'string' ? input : input.toString();
+        const method = init?.method || 'GET';
+        // Mask sensitive headers
+        const headers = init?.headers ? { ...init.headers } : {};
+        if (headers.Authorization) {
+            headers.Authorization = headers.Authorization.substring(0, 20) + '...[MASKED]';
+        }
+        const context = {
+            method,
+            url: url.length > 100 ? url.substring(0, 100) + '...' : url,
+            headers: Object.keys(headers),
+            bodySize: init?.body ? JSON.stringify(init.body).length : 0,
+        };
+        return trace.api(method, url, context, async () => {
+            const startTime = Date.now();
+            try {
+                const response = await baseFetch(input, init);
+                const duration = Date.now() - startTime;
+                // Log response details
+                logger.debug(`HTTP ${method} ${response.status}`, {
+                    url: url.substring(0, 100),
+                    status: response.status,
+                    duration,
+                    headers: {
+                        'content-type': response.headers.get('content-type'),
+                        'x-ratelimit-remaining': response.headers.get('x-ratelimit-remaining'),
+                        'x-ratelimit-reset': response.headers.get('x-ratelimit-reset'),
+                    },
+                });
+                // Warn about rate limiting
+                const remaining = response.headers.get('x-ratelimit-remaining');
+                if (remaining && parseInt(remaining) < 10) {
+                    logger.warn(`Low rate limit remaining: ${remaining}`, {
+                        url: url.substring(0, 100),
+                        resetAt: response.headers.get('x-ratelimit-reset'),
+                    });
+                }
+                // Warn about slow responses
+                if (duration > 2000) {
+                    logger.warn(`Slow HTTP response: ${duration}ms`, {
+                        method,
+                        url: url.substring(0, 100),
+                        status: response.status,
+                    });
+                }
+                return response;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                logger.error(`HTTP ${method} failed`, error, {
+                    url: url.substring(0, 100),
+                    duration,
+                    errorType: error.constructor.name,
+                    errno: error.errno,
+                    code: error.code,
+                });
+                throw error;
+            }
+        });
+    };
+}
+/**
+ * Create a traced GraphQL client wrapper
+ */
+export function wrapGraphQLClient(client) {
+    const prototype = Object.getPrototypeOf(client);
+    const propertyNames = Object.getOwnPropertyNames(prototype);
+    for (const propertyName of propertyNames) {
+        if (propertyName === 'constructor')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, propertyName);
+        if (!descriptor || typeof descriptor.value !== 'function')
+            continue;
+        // Apply tracing to all methods
+        TraceLinearAPI(prototype, propertyName, descriptor);
+        Object.defineProperty(prototype, propertyName, descriptor);
+    }
+    return client;
+}

package/scripts/update-linear-status.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+/**
+ * Update Linear task status based on actual implementation status
+ */
+
+import 'dotenv/config';
+
+const API_KEY = process.env.LINEAR_OAUTH_TOKEN || process.env.LINEAR_API_KEY;
+if (!API_KEY) {
+  console.error('❌ LINEAR_OAUTH_TOKEN or LINEAR_API_KEY environment variable not set');
+  console.log('Please set LINEAR_OAUTH_TOKEN or LINEAR_API_KEY in your .env file or export it in your shell');
+  process.exit(1);
+}
+
+// Tasks that should be marked as DONE based on commits and documentation
+const COMPLETED_TASKS = {
+  // Phase 1: Core Runtime - COMPLETE
+  'STA-279': 'Implement LLM-Driven Context Retrieval', // Implemented in llm-context-retrieval.ts
+  
+  // Phase 2: Intelligence Layer - COMPLETE  
+  'STA-280': 'Complete Hybrid Digest Generation (60/40)', // Implemented in hybrid-digest-generator.ts
+  'STA-281': 'Implement Smart Trace Detection and Bundling', // Implemented in trace detection
+  'STA-282': 'Implement Configurable Tool Scoring System', // Implemented with weight profiles
+  
+  // Phase 3: Collaboration - COMPLETE
+  'STA-283': 'Implement Dual Stack Architecture', // Implemented in dual-stack-manager.ts
+  'STA-284': 'Build Frame Handoff Mechanism', // Implemented in frame-handoff-manager.ts (v0.3.4)
+  'STA-271': '[STA-99] Phase 3: Dual Stack Architecture', // Completed in commit 111e51b
+  'STA-275': '[STA-100] Phase 3: Frame Handoff Mechanism', // Completed in commit b21574c
+  'STA-285': 'Implement Merge Conflict Resolution', // Implemented in stack-merge-resolver.ts
+  'STA-286': 'Build Team Analytics', // Basic analytics implemented
+  
+  // Additional completed features
+  'STA-276': '[STA-91] Finalize Session Persistence Design', // Implemented and documented
+  'STA-277': '[STA-90] Complete Linear MCP Integration Documentation', // MCP integration complete
+  'STA-155': '[STA-89] Complete Context Frame Manager Tests', // Tests completed
+};
+
+// Tasks in progress
+const IN_PROGRESS_TASKS = {
+  'STA-287': 'Implement Remote Infinite Storage System', // Railway storage partially done
+  'STA-288': 'Build Incremental Garbage Collection', // Basic GC implemented, needs enhancement
+};
+
+// Tasks to cancel (duplicates or no longer needed)
+const CANCEL_TASKS = {
+  'STA-272': 'Engineering x Marketing Team', // Meeting task
+  'STA-273': 'Engineering x Operations Team', // Meeting task  
+  'STA-274': 'Engineering x Success Team', // Meeting task
+  'STA-268': 'Task Analytics Dashboard', // Duplicate/outdated
+  'STA-264': 'Complete Documentation TODOs', // Low priority cleanup
+};
+
+async function getStateId(stateName) {
+  const query = `
+    query GetStates {
+      workflowStates {
+        nodes {
+          id
+          name
+          type
+        }
+      }
+    }
+  `;
+  
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query })
+  });
+  
+  const result = await response.json();
+  const state = result.data.workflowStates.nodes.find(s => 
+    s.name.toLowerCase() === stateName.toLowerCase() ||
+    (stateName === 'Done' && s.type === 'completed') ||
+    (stateName === 'In Progress' && s.type === 'started') ||
+    (stateName === 'Canceled' && s.type === 'canceled')
+  );
+  
+  return state?.id;
+}
+
+async function updateTaskStatus(taskId, stateId, description = null) {
+  const mutation = `
+    mutation UpdateIssue($id: String!, $stateId: String!, $description: String) {
+      issueUpdate(
+        id: $id,
+        input: { 
+          stateId: $stateId
+          ${description ? ', description: $description' : ''}
+        }
+      ) {
+        success
+        issue {
+          identifier
+          title
+          state {
+            name
+          }
+        }
+      }
+    }
+  `;
+  
+  const variables = { id: taskId, stateId };
+  if (description) variables.description = description;
+  
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query: mutation, variables })
+  });
+  
+  return response.json();
+}
+
+async function getTaskByIdentifier(identifier) {
+  const query = `
+    query GetIssue($identifier: String!) {
+      issue(id: $identifier) {
+        id
+        identifier
+        title
+        state {
+          name
+          type
+        }
+        description
+      }
+    }
+  `;
+  
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ 
+      query,
+      variables: { identifier }
+    })
+  });
+  
+  const result = await response.json();
+  return result.data?.issue;
+}
+
+async function updateLinearTasks() {
+  console.log('📊 Updating Linear task states based on actual implementation...\n');
+  
+  // Get state IDs
+  const doneStateId = await getStateId('Done');
+  const inProgressStateId = await getStateId('In Progress');
+  const canceledStateId = await getStateId('Canceled');
+  
+  if (!doneStateId || !inProgressStateId) {
+    console.error('❌ Could not find required workflow states');
+    return;
+  }
+  
+  let updated = 0;
+  let failed = 0;
+  
+  // Update completed tasks
+  console.log('✅ Marking completed tasks as Done:\n');
+  for (const [identifier, title] of Object.entries(COMPLETED_TASKS)) {
+    const task = await getTaskByIdentifier(identifier);
+    if (!task) {
+      console.log(`  ⚠️  ${identifier} not found`);
+      continue;
+    }
+    
+    if (task.state.type === 'completed') {
+      console.log(`  ✓ ${identifier} already Done`);
+      continue;
+    }
+    
+    const result = await updateTaskStatus(task.id, doneStateId);
+    if (result.data?.issueUpdate?.success) {
+      console.log(`  ✅ ${identifier}: ${title.substring(0, 40)}... → Done`);
+      updated++;
+    } else {
+      console.log(`  ❌ ${identifier}: Failed to update`);
+      failed++;
+    }
+    
+    // Small delay to avoid rate limits
+    await new Promise(r => setTimeout(r, 500));
+  }
+  
+  // Update in-progress tasks
+  console.log('\n🔄 Marking in-progress tasks:\n');
+  for (const [identifier, title] of Object.entries(IN_PROGRESS_TASKS)) {
+    const task = await getTaskByIdentifier(identifier);
+    if (!task) {
+      console.log(`  ⚠️  ${identifier} not found`);
+      continue;
+    }
+    
+    if (task.state.type === 'started') {
+      console.log(`  ✓ ${identifier} already In Progress`);
+      continue;
+    }
+    
+    const result = await updateTaskStatus(task.id, inProgressStateId);
+    if (result.data?.issueUpdate?.success) {
+      console.log(`  🔄 ${identifier}: ${title.substring(0, 40)}... → In Progress`);
+      updated++;
+    } else {
+      console.log(`  ❌ ${identifier}: Failed to update`);
+      failed++;
+    }
+    
+    await new Promise(r => setTimeout(r, 500));
+  }
+  
+  // Cancel obsolete tasks
+  if (canceledStateId) {
+    console.log('\n❌ Canceling obsolete tasks:\n');
+    for (const [identifier, title] of Object.entries(CANCEL_TASKS)) {
+      const task = await getTaskByIdentifier(identifier);
+      if (!task) {
+        console.log(`  ⚠️  ${identifier} not found`);
+        continue;
+      }
+      
+      if (task.state.type === 'canceled') {
+        console.log(`  ✓ ${identifier} already Canceled`);
+        continue;
+      }
+      
+      const result = await updateTaskStatus(task.id, canceledStateId);
+      if (result.data?.issueUpdate?.success) {
+        console.log(`  ❌ ${identifier}: ${title.substring(0, 40)}... → Canceled`);
+        updated++;
+      } else {
+        console.log(`  ❌ ${identifier}: Failed to update`);
+        failed++;
+      }
+      
+      await new Promise(r => setTimeout(r, 500));
+    }
+  }
+  
+  // Summary
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 UPDATE SUMMARY');
+  console.log('='.repeat(60));
+  console.log(`✅ Successfully updated: ${updated} tasks`);
+  console.log(`❌ Failed: ${failed} tasks`);
+  console.log('\nLinear backlog now reflects actual implementation status.');
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  updateLinearTasks().catch(console.error);
+}
+
+export { updateLinearTasks };