@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/development/fix-all-imports.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from 'fs';
+import { relative } from 'path';
+
+const fileFixes = [
+  // CLI files
+  {
+    file: 'src/cli/commands/projects.ts',
+    fixes: [
+      {
+        old: '../core/projects/project-manager',
+        new: '../../core/projects/project-manager',
+      },
+    ],
+  },
+  {
+    file: 'src/cli/index.ts',
+    fixes: [
+      {
+        old: '../integrations/linear-auth',
+        new: '../integrations/linear/auth',
+      },
+      {
+        old: '../integrations/linear-sync',
+        new: '../integrations/linear/sync',
+      },
+      {
+        old: '../integrations/linear-auto-sync',
+        new: '../integrations/linear/auto-sync',
+      },
+      { old: './analytics-viewer', new: './utils/viewer' },
+      { old: '../analytics/index', new: '../features/analytics/index' },
+      { old: '../mcp/mcp-server', new: '../integrations/mcp/server' },
+    ],
+  },
+
+  // Core files
+  {
+    file: 'src/core/context/frame-manager.ts',
+    fixes: [
+      { old: '../../core/monitoring/logger', new: '../monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/core/projects/project-manager.ts',
+    fixes: [
+      { old: '../../core/monitoring/logger', new: '../monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/core/utils/update-checker.ts',
+    fixes: [
+      { old: '../../core/monitoring/logger', new: '../monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/core/monitoring/error-handler.ts',
+    fixes: [{ old: '../../core/monitoring/logger', new: './logger' }],
+  },
+  {
+    file: 'src/core/logger.test.ts',
+    fixes: [
+      { old: '../../core/monitoring/logger', new: './monitoring/logger' },
+    ],
+  },
+
+  // Features files
+  {
+    file: 'src/features/tasks/pebbles-task-store.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/features/tasks/task-aware-context.ts',
+    fixes: [
+      {
+        old: '../core/context/frame-manager',
+        new: '../../core/context/frame-manager',
+      },
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/features/browser/browser-mcp.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/features/analytics/core/analytics-service.ts',
+    fixes: [
+      {
+        old: '../../integrations/linear/client',
+        new: '../../../integrations/linear/client',
+      },
+    ],
+  },
+
+  // Integrations files
+  {
+    file: 'src/integrations/linear/auth.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/integrations/linear/auto-sync.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+      {
+        old: '../features/tasks/pebbles-task-store',
+        new: '../../features/tasks/pebbles-task-store',
+      },
+    ],
+  },
+  {
+    file: 'src/integrations/linear/client.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/integrations/linear/config.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+    ],
+  },
+  {
+    file: 'src/integrations/linear/sync.ts',
+    fixes: [
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+      {
+        old: '../pebbles/pebbles-task-store',
+        new: '../../features/tasks/pebbles-task-store',
+      },
+    ],
+  },
+  {
+    file: 'src/integrations/mcp/server.ts',
+    fixes: [
+      {
+        old: '../core/context/frame-manager',
+        new: '../../core/context/frame-manager',
+      },
+      {
+        old: '../pebbles/pebbles-task-store',
+        new: '../../features/tasks/pebbles-task-store',
+      },
+      { old: '../core/monitoring/logger', new: '../../core/monitoring/logger' },
+      {
+        old: '../features/browser/browser-mcp',
+        new: '../../features/browser/browser-mcp',
+      },
+    ],
+  },
+
+  // Servers files
+  {
+    file: 'src/servers/production/auth-middleware.ts',
+    fixes: [
+      {
+        old: '../../core/monitoring/metrics',
+        new: '../../core/monitoring/metrics',
+      },
+    ],
+  },
+  {
+    file: 'src/servers/railway/index.ts',
+    fixes: [
+      {
+        old: '../features/browser/browser-mcp',
+        new: '../../features/browser/browser-mcp',
+      },
+    ],
+  },
+];
+
+console.log('🔄 Fixing all import paths...\n');
+
+let totalFixed = 0;
+
+for (const { file, fixes } of fileFixes) {
+  try {
+    let content = readFileSync(file, 'utf-8');
+    let modified = false;
+
+    for (const { old: oldPath, new: newPath } of fixes) {
+      const importRegex = new RegExp(
+        `(import.*from\\s+['"])${oldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\.js)?(['"])`,
+        'g'
+      );
+      const newContent = content.replace(importRegex, `$1${newPath}.js$3`);
+
+      if (newContent !== content) {
+        content = newContent;
+        modified = true;
+      }
+    }
+
+    if (modified) {
+      writeFileSync(file, content);
+      console.log(`✅ Fixed: ${relative(process.cwd(), file)}`);
+      totalFixed++;
+    }
+  } catch (error) {
+    console.error(`❌ Error fixing ${file}:`, error.message);
+  }
+}
+
+console.log(`\n✅ Fixed ${totalFixed} files`);
+console.log('📦 Run "npm run build" to verify all imports are correct');

package/scripts/development/fix-imports.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, dirname, resolve } from 'path';
+
+const importMappings = {
+  // Core monitoring imports
+  '../core/logger': '../core/monitoring/logger',
+  './logger': '../monitoring/logger',
+  '../core/error-handler': '../core/monitoring/error-handler',
+  './error-handler': '../monitoring/error-handler',
+  '../core/progress-tracker': '../core/monitoring/progress-tracker',
+
+  // Core context imports
+  '../core/frame-manager': '../core/context/frame-manager',
+  './core/frame-manager': './core/context/frame-manager',
+
+  // Core projects imports
+  '../core/project-manager': '../core/projects/project-manager',
+  './core/project-manager': './core/projects/project-manager',
+
+  // Core utils imports
+  '../core/update-checker': '../core/utils/update-checker',
+  './core/update-checker': './core/utils/update-checker',
+
+  // Features imports
+  '../pebbles/pebbles-task-store': '../features/tasks/pebbles-task-store',
+  './pebbles/pebbles-task-store': './features/tasks/pebbles-task-store',
+  '../pebbles/task-aware-context': '../features/tasks/task-aware-context',
+  '../analytics/index': '../features/analytics/index',
+  './analytics/index': './features/analytics/index',
+  '../analytics/core/analytics-service':
+    '../../features/analytics/core/analytics-service',
+  '../integrations/browser-mcp': '../features/browser/browser-mcp',
+
+  // Linear integration imports
+  '../integrations/linear-auth': '../integrations/linear/auth',
+  './linear-auth': './auth',
+  '../integrations/linear-sync': '../integrations/linear/sync',
+  './linear-sync': './sync',
+  '../integrations/linear-client': '../integrations/linear/client',
+  './linear-client': './client',
+  '../../integrations/linear-client': '../../integrations/linear/client',
+  '../integrations/linear-config': '../integrations/linear/config',
+  './linear-config': './config',
+  '../integrations/linear-auto-sync': '../integrations/linear/auto-sync',
+  './linear-auto-sync': './auto-sync',
+
+  // MCP imports
+  '../mcp/mcp-server': '../integrations/mcp/server',
+  './mcp/mcp-server': './integrations/mcp/server',
+
+  // CLI imports
+  './project-commands': './commands/projects',
+  './analytics-viewer': './utils/viewer',
+  '../cli/cli': '../cli/index',
+
+  // Production server imports
+  '../monitoring/logger': '../../core/monitoring/logger',
+  '../monitoring/metrics': '../../core/monitoring/metrics',
+};
+
+function getCorrectRelativePath(fromFile, toFile) {
+  const fromDir = dirname(fromFile);
+  let relativePath = relative(fromDir, toFile).replace(/\\/g, '/');
+  if (!relativePath.startsWith('.')) {
+    relativePath = './' + relativePath;
+  }
+  // Remove .ts extension for imports
+  relativePath = relativePath.replace(/\.ts$/, '');
+  return relativePath;
+}
+
+function fixImportsInFile(filePath) {
+  if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+    return false;
+  }
+
+  try {
+    let content = readFileSync(filePath, 'utf-8');
+    let modified = false;
+
+    // Fix each known import mapping
+    for (const [oldPath, newPath] of Object.entries(importMappings)) {
+      const importRegex = new RegExp(
+        `(import.*from\\s+['"])${escapeRegex(oldPath)}(\\.js)?(['"])`,
+        'g'
+      );
+      const requireRegex = new RegExp(
+        `(require\\(['"])${escapeRegex(oldPath)}(\\.js)?(['"])`,
+        'g'
+      );
+
+      const newContent = content
+        .replace(importRegex, `$1${newPath}.js$3`)
+        .replace(requireRegex, `$1${newPath}.js$3`);
+
+      if (newContent !== content) {
+        content = newContent;
+        modified = true;
+      }
+    }
+
+    // Special fixes for specific files
+    if (filePath.includes('src/cli/index.ts')) {
+      // Add shebang if missing
+      if (!content.startsWith('#!/usr/bin/env node')) {
+        content = '#!/usr/bin/env node\n' + content;
+        modified = true;
+      }
+    }
+
+    // Fix imports in specific directories
+    if (filePath.includes('src/core/context/')) {
+      content = content.replace(
+        /from ['"]\.\/logger\.js['"]/g,
+        `from '../monitoring/logger.js'`
+      );
+      content = content.replace(
+        /from ['"]\.\/error-handler\.js['"]/g,
+        `from '../monitoring/error-handler.js'`
+      );
+      modified = true;
+    }
+
+    if (filePath.includes('src/core/projects/')) {
+      content = content.replace(
+        /from ['"]\.\/logger\.js['"]/g,
+        `from '../monitoring/logger.js'`
+      );
+      modified = true;
+    }
+
+    if (filePath.includes('src/core/utils/')) {
+      content = content.replace(
+        /from ['"]\.\/logger\.js['"]/g,
+        `from '../monitoring/logger.js'`
+      );
+      modified = true;
+    }
+
+    if (filePath.includes('src/integrations/linear/')) {
+      // Fix relative imports within linear directory
+      content = content.replace(
+        /from ['"]\.\/linear-auth\.js['"]/g,
+        `from './auth.js'`
+      );
+      content = content.replace(
+        /from ['"]\.\/linear-sync\.js['"]/g,
+        `from './sync.js'`
+      );
+      content = content.replace(
+        /from ['"]\.\/linear-client\.js['"]/g,
+        `from './client.js'`
+      );
+      content = content.replace(
+        /from ['"]\.\/linear-config\.js['"]/g,
+        `from './config.js'`
+      );
+      content = content.replace(
+        /from ['"]\.\/linear-auto-sync\.js['"]/g,
+        `from './auto-sync.js'`
+      );
+      modified = true;
+    }
+
+    if (modified) {
+      writeFileSync(filePath, content);
+      console.log(`✅ Fixed: ${relative(process.cwd(), filePath)}`);
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    console.error(`❌ Error fixing ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function walkDirectory(dir) {
+  const files = [];
+
+  try {
+    const items = readdirSync(dir);
+
+    for (const item of items) {
+      const fullPath = join(dir, item);
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        // Skip node_modules, dist, and .git
+        if (
+          !item.startsWith('.') &&
+          item !== 'node_modules' &&
+          item !== 'dist'
+        ) {
+          files.push(...walkDirectory(fullPath));
+        }
+      } else if (stat.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error walking directory ${dir}:`, error.message);
+  }
+
+  return files;
+}
+
+// Main execution
+console.log('🔄 Fixing import paths after reorganization...\n');
+
+const srcFiles = walkDirectory(join(process.cwd(), 'src'));
+const testFiles = walkDirectory(join(process.cwd(), 'tests'));
+
+let fixedCount = 0;
+
+for (const file of [...srcFiles, ...testFiles]) {
+  if (fixImportsInFile(file)) {
+    fixedCount++;
+  }
+}
+
+console.log(`\n✅ Fixed ${fixedCount} files`);
+console.log('📦 Run "npm run build" to verify all imports are correct');

package/scripts/development/fix-lint-loop.cjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * Auto-fix lint errors in a loop until only warnings remain
+ * Outputs detailed fix log for Claude to review
+ */
+
+const { execSync } = require('child_process');
+const { writeFileSync } = require('fs');
+
+const MAX_ATTEMPTS = 3;
+let attempt = 0;
+const fixLog = [];
+
+function logFix(message, level = 'info') {
+  const timestamp = new Date().toISOString();
+  const entry = { timestamp, level, message };
+  fixLog.push(entry);
+  console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`);
+}
+
+function saveLintReport(output, filename) {
+  try {
+    writeFileSync(filename, output);
+    logFix(`Lint report saved to ${filename}`, 'info');
+  } catch (err) {
+    logFix(`Failed to save lint report: ${err.message}`, 'error');
+  }
+}
+
+logFix('🔧 Starting auto-fix loop...');
+
+while (attempt < MAX_ATTEMPTS) {
+  attempt++;
+  logFix(`📝 Auto-fix attempt ${attempt}/${MAX_ATTEMPTS}`);
+  
+  try {
+    // Get initial errors for comparison
+    let beforeOutput = '';
+    try {
+      execSync('npx eslint src/**/*.ts scripts/**/*.ts', { stdio: 'pipe' });
+    } catch (beforeError) {
+      beforeOutput = beforeError.stdout?.toString() || '';
+      const errorCount = (beforeOutput.match(/\s+error\s+/g) || []).length;
+      const warningCount = (beforeOutput.match(/\s+warning\s+/g) || []).length;
+      logFix(`Found ${errorCount} errors, ${warningCount} warnings before auto-fix`);
+    }
+    
+    // Try to fix what can be auto-fixed
+    logFix('Running ESLint auto-fix...');
+    try {
+      execSync('npx eslint src/**/*.ts scripts/**/*.ts --fix', { 
+        stdio: 'pipe' 
+      });
+    } catch (fixError) {
+      // ESLint fix command can fail but still make fixes
+      logFix('ESLint --fix completed (may have remaining issues)');
+    }
+    
+    // Check results after fix
+    let afterOutput = '';
+    try {
+      execSync('npx eslint src/**/*.ts scripts/**/*.ts --max-warnings 999', { 
+        stdio: 'pipe' 
+      });
+      
+      logFix('✅ All fixable lint errors resolved! (warnings are ok for commits)', 'success');
+      saveLintReport(JSON.stringify(fixLog, null, 2), '.lint-fix-log.json');
+      process.exit(0);
+      
+    } catch (afterError) {
+      afterOutput = afterError.stdout?.toString() || '';
+      const remainingErrors = (afterOutput.match(/\s+error\s+/g) || []).length;
+      const remainingWarnings = (afterOutput.match(/\s+warning\s+/g) || []).length;
+      logFix(`After auto-fix: ${remainingErrors} errors, ${remainingWarnings} warnings`);
+    }
+    
+    // Check if only warnings remain
+    if (!afterOutput.includes(' error ') && afterOutput.includes(' warning ')) {
+      logFix('✅ Only warnings remain - allowing commit!', 'success');
+      logFix('💡 Consider fixing warnings when convenient', 'info');
+      saveLintReport(afterOutput, '.lint-warnings.log');
+      saveLintReport(JSON.stringify(fixLog, null, 2), '.lint-fix-log.json');
+      process.exit(0);
+    }
+    
+    if (attempt === MAX_ATTEMPTS) {
+      logFix(`❌ Could not auto-fix all errors after ${MAX_ATTEMPTS} attempts`, 'error');
+      logFix('🚫 Blocking commit - errors require manual attention:', 'error');
+      saveLintReport(afterOutput, '.lint-errors.log');
+      saveLintReport(JSON.stringify(fixLog, null, 2), '.lint-fix-log.json');
+      console.log('\n' + afterOutput);
+      process.exit(1);
+    } else {
+      logFix(`⚠️ ${(afterOutput.match(/\s+error\s+/g) || []).length} errors remain, trying again...`, 'warn');
+    }
+    
+  } catch (error) {
+    logFix(`Unexpected error: ${error.message}`, 'error');
+    if (attempt === MAX_ATTEMPTS) {
+      process.exit(1);
+    }
+  }
+}

package/scripts/development/fix-project-id.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env tsx
+/**
+ * Fix project ID mismatch between sessions and database
+ */
+
+import Database from 'better-sqlite3';
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+// Get the actual project ID from git remote
+function getProjectId(): string {
+  try {
+    const gitUrl = execSync('git config --get remote.origin.url', {
+      encoding: 'utf-8',
+    }).trim();
+
+    // Transform URL to project ID (same as session-manager logic)
+    const cleaned = gitUrl
+      .replace(/\.git$/, '')
+      .replace(/[^a-zA-Z0-9-]/g, '-')
+      .toLowerCase();
+
+    // Take last 50 chars
+    return cleaned.substring(cleaned.length - 50);
+  } catch {
+    console.error(chalk.red('Failed to get git remote URL'));
+    return 'stackmemory-demo';
+  }
+}
+
+// Fix database project IDs
+function fixDatabase(projectId: string): void {
+  const dbPath = join(process.cwd(), '.stackmemory', 'context.db');
+
+  if (!existsSync(dbPath)) {
+    console.error(chalk.red('Database not found'));
+    return;
+  }
+
+  const db = new Database(dbPath);
+
+  // Check current project IDs in frames
+  const projectIds = db
+    .prepare('SELECT DISTINCT project_id FROM frames')
+    .all() as Array<{ project_id: string }>;
+  console.log(chalk.blue('Current project IDs in database:'));
+  projectIds.forEach((p) => console.log(`  - ${p.project_id}`));
+
+  // Update frames if needed
+  const wrongIds = projectIds.filter((p) => p.project_id !== projectId);
+  if (wrongIds.length > 0) {
+    console.log(
+      chalk.yellow(
+        `\nUpdating ${wrongIds.length} project ID(s) to: ${projectId}`
+      )
+    );
+
+    wrongIds.forEach((p) => {
+      const result = db
+        .prepare('UPDATE frames SET project_id = ? WHERE project_id = ?')
+        .run(projectId, p.project_id);
+      console.log(`  Updated ${result.changes} frames from ${p.project_id}`);
+    });
+  } else {
+    console.log(chalk.green('\nDatabase project IDs are already correct'));
+  }
+
+  db.close();
+}
+
+// Fix session files
+function fixSessions(projectId: string): void {
+  const sessionsDir = join(
+    process.env['HOME'] || '',
+    '.stackmemory',
+    'sessions',
+    'projects'
+  );
+
+  if (!existsSync(sessionsDir)) {
+    console.error(chalk.red('Sessions directory not found'));
+    return;
+  }
+
+  const files = readdirSync(sessionsDir).filter((f) => f.endsWith('.json'));
+
+  console.log(chalk.blue(`\nChecking ${files.length} session files...`));
+
+  files.forEach((file) => {
+    const filePath = join(sessionsDir, file);
+    const content = JSON.parse(readFileSync(filePath, 'utf-8'));
+
+    if (content.projectId && content.projectId !== projectId) {
+      // Check if this session belongs to our project
+      if (
+        content.projectId === 'stackmemory-demo' ||
+        content.projectId.includes('stackmemory')
+      ) {
+        console.log(
+          chalk.yellow(
+            `  Updating session ${file}: ${content.projectId} → ${projectId}`
+          )
+        );
+        content.projectId = projectId;
+        writeFileSync(filePath, JSON.stringify(content, null, 2));
+      }
+    }
+  });
+
+  // Also check for individual session files
+  const individualSessionsDir = join(
+    process.env['HOME'] || '',
+    '.stackmemory',
+    'sessions'
+  );
+  const sessionPattern =
+    /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\.json/;
+
+  if (existsSync(individualSessionsDir)) {
+    const sessionFiles = readdirSync(individualSessionsDir).filter((f) =>
+      sessionPattern.test(f)
+    );
+
+    sessionFiles.forEach((file) => {
+      const filePath = join(individualSessionsDir, file);
+      const content = JSON.parse(readFileSync(filePath, 'utf-8'));
+
+      if (content.projectId && content.projectId !== projectId) {
+        if (
+          content.projectId === 'stackmemory-demo' ||
+          content.projectId.includes('stackmemory')
+        ) {
+          console.log(
+            chalk.yellow(
+              `  Updating session ${file}: ${content.projectId} → ${projectId}`
+            )
+          );
+          content.projectId = projectId;
+          writeFileSync(filePath, JSON.stringify(content, null, 2));
+        }
+      }
+    });
+  }
+}
+
+// Main
+console.log(chalk.bold.blue('\n🔧 StackMemory Project ID Fix\n'));
+
+const correctProjectId = getProjectId();
+console.log(chalk.green(`Correct project ID: ${correctProjectId}\n`));
+
+// Fix database
+fixDatabase(correctProjectId);
+
+// Fix sessions
+fixSessions(correctProjectId);
+
+console.log(chalk.bold.green('\n✅ Project ID fix complete!\n'));
+console.log('Run "stackmemory status" to verify the fix.');